(function (f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.mqtt = f() } })(function () {
  var define, module, exports; return (function () { function r(e, n, t) { function o(i, f) { if (!n[i]) { if (!e[i]) { var c = "function" == typeof require && require; if (!f && c) return c(i, !0); if (u) return u(i, !0); var a = new Error("Cannot find module '" + i + "'"); throw a.code = "MODULE_NOT_FOUND", a } var p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { var n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (var u = "function" == typeof require && require, i = 0; i < t.length; i++)o(t[i]); return o } return r })()({
    1: [function (require, module, exports) {
      (function (process, global) {
        'use strict'

        /**
         * Module dependencies
         */
        var EventEmitter = require('events').EventEmitter
        var Store = require('./store')
        var mqttPacket = require('mqtt-packet')
        var Writable = require('readable-stream').Writable
        var inherits = require('inherits')
        var reInterval = require('reinterval')
        var validations = require('./validations')
        var xtend = require('xtend')
        var debug = require('debug')('mqttjs:client')
        var setImmediate = global.setImmediate || function (callback) {
          // works in node v0.8
          process.nextTick(callback)
        }
        var defaultConnectOptions = {
          keepalive: 60,
          reschedulePings: true,
          protocolId: 'MQTT',
          protocolVersion: 4,
          reconnectPeriod: 1000,
          connectTimeout: 30 * 1000,
          clean: true,
          resubscribe: true
        }

        var socketErrors = [
          'ECONNREFUSED',
          'EADDRINUSE',
          'ECONNRESET',
          'ENOTFOUND'
        ]

        // Other Socket Errors: EADDRINUSE, ECONNRESET, ENOTFOUND.

        var errors = {
          0: '',
          1: 'Unacceptable protocol version',
          2: 'Identifier rejected',
          3: 'Server unavailable',
          4: 'Bad username or password',
          5: 'Not authorized',
          16: 'No matching subscribers',
          17: 'No subscription existed',
          128: 'Unspecified error',
          129: 'Malformed Packet',
          130: 'Protocol Error',
          131: 'Implementation specific error',
          132: 'Unsupported Protocol Version',
          133: 'Client Identifier not valid',
          134: 'Bad User Name or Password',
          135: 'Not authorized',
          136: 'Server unavailable',
          137: 'Server busy',
          138: 'Banned',
          139: 'Server shutting down',
          140: 'Bad authentication method',
          141: 'Keep Alive timeout',
          142: 'Session taken over',
          143: 'Topic Filter invalid',
          144: 'Topic Name invalid',
          145: 'Packet identifier in use',
          146: 'Packet Identifier not found',
          147: 'Receive Maximum exceeded',
          148: 'Topic Alias invalid',
          149: 'Packet too large',
          150: 'Message rate too high',
          151: 'Quota exceeded',
          152: 'Administrative action',
          153: 'Payload format invalid',
          154: 'Retain not supported',
          155: 'QoS not supported',
          156: 'Use another server',
          157: 'Server moved',
          158: 'Shared Subscriptions not supported',
          159: 'Connection rate exceeded',
          160: 'Maximum connect time',
          161: 'Subscription Identifiers not supported',
          162: 'Wildcard Subscriptions not supported'
        }

        function defaultId() {
          return 'mqttjs_' + Math.random().toString(16).substr(2, 8)
        }

        function sendPacket(client, packet, cb) {
          debug('sendPacket :: packet: %O', packet)
          debug('sendPacket :: emitting `packetsend`')
          client.emit('packetsend', packet)

          debug('sendPacket :: writing to stream')
          var result = mqttPacket.writeToStream(packet, client.stream, client.options)
          debug('sendPacket :: writeToStream result %s', result)
          if (!result && cb) {
            debug('sendPacket :: handle events on `drain` once through callback.')
            client.stream.once('drain', cb)
          } else if (cb) {
            debug('sendPacket :: invoking cb')
            cb()
          }
        }

        function flush(queue) {
          if (queue) {
            debug('flush: queue exists? %b', !!(queue))
            Object.keys(queue).forEach(function (messageId) {
              if (typeof queue[messageId].cb === 'function') {
                queue[messageId].cb(new Error('Connection closed'))
                delete queue[messageId]
              }
            })
          }
        }

        function flushVolatile(queue) {
          if (queue) {
            debug('flushVolatile :: deleting volatile messages from the queue and setting their callbacks as error function')
            Object.keys(queue).forEach(function (messageId) {
              if (queue[messageId].volatile && typeof queue[messageId].cb === 'function') {
                queue[messageId].cb(new Error('Connection closed'))
                delete queue[messageId]
              }
            })
          }
        }

        function storeAndSend(client, packet, cb, cbStorePut) {
          debug('storeAndSend :: store packet with cmd %s to outgoingStore', packet.cmd)
          client.outgoingStore.put(packet, function storedPacket(err) {
            if (err) {
              return cb && cb(err)
            }
            cbStorePut()
            sendPacket(client, packet, cb)
          })
        }

        function nop(error) {
          debug('nop ::', error)
        }

        /**
         * MqttClient constructor
         *
         * @param {Stream} stream - stream
         * @param {Object} [options] - connection options
         * (see Connection#connect)
         */
        function MqttClient(streamBuilder, options) {
          var k
          var that = this

          if (!(this instanceof MqttClient)) {
            return new MqttClient(streamBuilder, options)
          }

          this.options = options || {}

          // Defaults
          for (k in defaultConnectOptions) {
            if (typeof this.options[k] === 'undefined') {
              this.options[k] = defaultConnectOptions[k]
            } else {
              this.options[k] = options[k]
            }
          }

          debug('MqttClient :: options.protocol', options.protocol)
          debug('MqttClient :: options.protocolVersion', options.protocolVersion)
          debug('MqttClient :: options.username', options.username)
          debug('MqttClient :: options.keepalive', options.keepalive)
          debug('MqttClient :: options.reconnectPeriod', options.reconnectPeriod)
          debug('MqttClient :: options.rejectUnauthorized', options.rejectUnauthorized)

          this.options.clientId = (typeof options.clientId === 'string') ? options.clientId : defaultId()

          debug('MqttClient :: clientId', this.options.clientId)

          this.options.customHandleAcks = (options.protocolVersion === 5 && options.customHandleAcks) ? options.customHandleAcks : function () { arguments[3](0) }

          this.streamBuilder = streamBuilder

          // Inflight message storages
          this.outgoingStore = options.outgoingStore || new Store()
          this.incomingStore = options.incomingStore || new Store()

          // Should QoS zero messages be queued when the connection is broken?
          this.queueQoSZero = options.queueQoSZero === undefined ? true : options.queueQoSZero

          // map of subscribed topics to support reconnection
          this._resubscribeTopics = {}

          // map of a subscribe messageId and a topic
          this.messageIdToTopic = {}

          // Ping timer, setup in _setupPingTimer
          this.pingTimer = null
          // Is the client connected?
          this.connected = false
          // Are we disconnecting?
          this.disconnecting = false
          // Packet queue
          this.queue = []
          // connack timer
          this.connackTimer = null
          // Reconnect timer
          this.reconnectTimer = null
          // Is processing store?
          this._storeProcessing = false
          // Packet Ids are put into the store during store processing
          this._packetIdsDuringStoreProcessing = {}
          /**
           * MessageIDs starting with 1
           * ensure that nextId is min. 1, see https://github.com/mqttjs/MQTT.js/issues/810
           */
          this.nextId = Math.max(1, Math.floor(Math.random() * 65535))

          // Inflight callbacks
          this.outgoing = {}

          // True if connection is first time.
          this._firstConnection = true

          // Send queued packets
          this.on('connect', function () {
            var queue = this.queue

            function deliver() {
              var entry = queue.shift()
              debug('deliver :: entry %o', entry)
              var packet = null

              if (!entry) {
                return
              }

              packet = entry.packet
              debug('deliver :: call _sendPacket for %o', packet)
              that._sendPacket(
                packet,
                function (err) {
                  if (entry.cb) {
                    entry.cb(err)
                  }
                  deliver()
                }
              )
            }

            debug('connect :: sending queued packets')
            deliver()
          })

          this.on('close', function () {
            debug('close :: connected set to `false`')
            this.connected = false

            debug('close :: clearing connackTimer')
            clearTimeout(this.connackTimer)

            debug('close :: clearing ping timer')
            if (that.pingTimer !== null) {
              that.pingTimer.clear()
              that.pingTimer = null
            }

            debug('close :: calling _setupReconnect')
            this._setupReconnect()
          })
          EventEmitter.call(this)

          debug('MqttClient :: setting up stream')
          this._setupStream()
        }
        inherits(MqttClient, EventEmitter)

        /**
         * setup the event handlers in the inner stream.
         *
         * @api private
         */
        MqttClient.prototype._setupStream = function () {
          var connectPacket
          var that = this
          var writable = new Writable()
          var parser = mqttPacket.parser(this.options)
          var completeParse = null
          var packets = []

          debug('_setupStream :: calling method to clear reconnect')
          this._clearReconnect()

          debug('_setupStream :: using streamBuilder provided to client to create stream')
          this.stream = this.streamBuilder(this)

          parser.on('packet', function (packet) {
            debug('parser :: on packet push to packets array.')
            packets.push(packet)
          })

          function nextTickWork() {
            if (packets.length) {
              process.nextTick(work)
            } else {
              var done = completeParse
              completeParse = null
              done()
            }
          }

          function work() {
            debug('work :: getting next packet in queue')
            var packet = packets.shift()

            if (packet) {
              debug('work :: packet pulled from queue')
              that._handlePacket(packet, nextTickWork)
            } else {
              debug('work :: no packets in queue')
              var done = completeParse
              completeParse = null
              debug('work :: done flag is %s', !!(done))
              if (done) done()
            }
          }

          writable._write = function (buf, enc, done) {
            completeParse = done
            debug('writable stream :: parsing buffer')
            parser.parse(buf)
            work()
          }

          function streamErrorHandler(error) {
            debug('streamErrorHandler :: error', error.message)
            if (socketErrors.includes(error.code)) {
              // handle error
              debug('streamErrorHandler :: emitting error')
              that.emit('error', error)
            } else {
              nop(error)
            }
          }

          debug('_setupStream :: pipe stream to writable stream')
          this.stream.pipe(writable)

          // Suppress connection errors
          this.stream.on('error', streamErrorHandler)

          // Echo stream close
          this.stream.on('close', function () {
            debug('(%s)stream :: on close', that.options.clientId)
            flushVolatile(that.outgoing)
            debug('stream: emit close to MqttClient')
            that.emit('close')
          })

          // Send a connect packet
          debug('_setupStream: sending packet `connect`')
          connectPacket = Object.create(this.options)
          connectPacket.cmd = 'connect'
          // avoid message queue
          sendPacket(this, connectPacket)

          // Echo connection errors
          parser.on('error', this.emit.bind(this, 'error'))

          // auth
          if (this.options.properties) {
            if (!this.options.properties.authenticationMethod && this.options.properties.authenticationData) {
              that.end(() =>
                this.emit('error', new Error('Packet has no Authentication Method')
                ))
              return this
            }
            if (this.options.properties.authenticationMethod && this.options.authPacket && typeof this.options.authPacket === 'object') {
              var authPacket = xtend({ cmd: 'auth', reasonCode: 0 }, this.options.authPacket)
              sendPacket(this, authPacket)
            }
          }

          // many drain listeners are needed for qos 1 callbacks if the connection is intermittent
          this.stream.setMaxListeners(1000)

          clearTimeout(this.connackTimer)
          this.connackTimer = setTimeout(function () {
            debug('!!connectTimeout hit!! Calling _cleanUp with force `true`')
            that._cleanUp(true)
          }, this.options.connectTimeout)
        }

        MqttClient.prototype._handlePacket = function (packet, done) {
          var options = this.options

          if (options.protocolVersion === 5 && options.properties && options.properties.maximumPacketSize && options.properties.maximumPacketSize < packet.length) {
            this.emit('error', new Error('exceeding packets size ' + packet.cmd))
            this.end({ reasonCode: 149, properties: { reasonString: 'Maximum packet size was exceeded' } })
            return this
          }
          debug('_handlePacket :: emitting packetreceive')
          this.emit('packetreceive', packet)

          switch (packet.cmd) {
            case 'publish':
              this._handlePublish(packet, done)
              break
            case 'puback':
            case 'pubrec':
            case 'pubcomp':
            case 'suback':
            case 'unsuback':
              this._handleAck(packet)
              done()
              break
            case 'pubrel':
              this._handlePubrel(packet, done)
              break
            case 'connack':
              this._handleConnack(packet)
              done()
              break
            case 'pingresp':
              this._handlePingresp(packet)
              done()
              break
            case 'disconnect':
              this._handleDisconnect(packet)
              done()
              break
            default:
              // do nothing
              // maybe we should do an error handling
              // or just log it
              break
          }
        }

        MqttClient.prototype._checkDisconnecting = function (callback) {
          if (this.disconnecting) {
            if (callback) {
              callback(new Error('client disconnecting'))
            } else {
              this.emit('error', new Error('client disconnecting'))
            }
          }
          return this.disconnecting
        }

        /**
         * publish - publish <message> to <topic>
         *
         * @param {String} topic - topic to publish to
         * @param {String, Buffer} message - message to publish
         * @param {Object} [opts] - publish options, includes:
         *    {Number} qos - qos level to publish on
         *    {Boolean} retain - whether or not to retain the message
         *    {Boolean} dup - whether or not mark a message as duplicate
         *    {Function} cbStorePut - function(){} called when message is put into `outgoingStore`
         * @param {Function} [callback] - function(err){}
         *    called when publish succeeds or fails
         * @returns {MqttClient} this - for chaining
         * @api public
         *
         * @example client.publish('topic', 'message');
         * @example
         *     client.publish('topic', 'message', {qos: 1, retain: true, dup: true});
         * @example client.publish('topic', 'message', console.log);
         */
        MqttClient.prototype.publish = function (topic, message, opts, callback) {
          debug('publish :: message `%s` to topic `%s`', message, topic)
          var packet
          var options = this.options

          // .publish(topic, payload, cb);
          if (typeof opts === 'function') {
            callback = opts
            opts = null
          }

          // default opts
          var defaultOpts = { qos: 0, retain: false, dup: false }
          opts = xtend(defaultOpts, opts)

          if (this._checkDisconnecting(callback)) {
            return this
          }

          packet = {
            cmd: 'publish',
            topic: topic,
            payload: message,
            qos: opts.qos,
            retain: opts.retain,
            messageId: this._nextId(),
            dup: opts.dup
          }

          if (options.protocolVersion === 5) {
            packet.properties = opts.properties
            if ((!options.properties && packet.properties && packet.properties.topicAlias) || ((opts.properties && options.properties) &&
              ((opts.properties.topicAlias && options.properties.topicAliasMaximum && opts.properties.topicAlias > options.properties.topicAliasMaximum) ||
                (!options.properties.topicAliasMaximum && opts.properties.topicAlias)))) {
              /*
              if we are don`t setup topic alias or
              topic alias maximum less than topic alias or
              server don`t give topic alias maximum,
              we are removing topic alias from packet
              */
              delete packet.properties.topicAlias
            }
          }

          debug('publish :: qos', opts.qos)
          switch (opts.qos) {
            case 1:
            case 2:
              // Add to callbacks
              this.outgoing[packet.messageId] = {
                volatile: false,
                cb: callback || nop
              }
              if (this._storeProcessing) {
                debug('_storeProcessing enabled')
                this._packetIdsDuringStoreProcessing[packet.messageId] = false
                this._storePacket(packet, undefined, opts.cbStorePut)
              } else {
                debug('MqttClient:publish: packet cmd: %s', packet.cmd)
                this._sendPacket(packet, undefined, opts.cbStorePut)
              }
              break
            default:
              if (this._storeProcessing) {
                debug('_storeProcessing enabled')
                this._storePacket(packet, callback, opts.cbStorePut)
              } else {
                debug('MqttClient:publish: packet cmd: %s', packet.cmd)
                this._sendPacket(packet, callback, opts.cbStorePut)
              }
              break
          }

          return this
        }

        /**
         * subscribe - subscribe to <topic>
         *
         * @param {String, Array, Object} topic - topic(s) to subscribe to, supports objects in the form {'topic': qos}
         * @param {Object} [opts] - optional subscription options, includes:
         *    {Number} qos - subscribe qos level
         * @param {Function} [callback] - function(err, granted){} where:
         *    {Error} err - subscription error (none at the moment!)
         *    {Array} granted - array of {topic: 't', qos: 0}
         * @returns {MqttClient} this - for chaining
         * @api public
         * @example client.subscribe('topic');
         * @example client.subscribe('topic', {qos: 1});
         * @example client.subscribe({'topic': {qos: 0}, 'topic2': {qos: 1}}, console.log);
         * @example client.subscribe('topic', console.log);
         */
        MqttClient.prototype.subscribe = function () {
          var packet
          var args = new Array(arguments.length)
          for (var i = 0; i < arguments.length; i++) {
            args[i] = arguments[i]
          }
          var subs = []
          var obj = args.shift()
          var resubscribe = obj.resubscribe
          var callback = args.pop() || nop
          var opts = args.pop()
          var invalidTopic
          var that = this
          var version = this.options.protocolVersion

          delete obj.resubscribe

          if (typeof obj === 'string') {
            obj = [obj]
          }

          if (typeof callback !== 'function') {
            opts = callback
            callback = nop
          }

          invalidTopic = validations.validateTopics(obj)
          if (invalidTopic !== null) {
            setImmediate(callback, new Error('Invalid topic ' + invalidTopic))
            return this
          }

          if (this._checkDisconnecting(callback)) {
            debug('subscribe: discconecting true')
            return this
          }

          var defaultOpts = {
            qos: 0
          }
          if (version === 5) {
            defaultOpts.nl = false
            defaultOpts.rap = false
            defaultOpts.rh = 0
          }
          opts = xtend(defaultOpts, opts)

          if (Array.isArray(obj)) {
            obj.forEach(function (topic) {
              debug('subscribe: array topic %s', topic)
              if (!that._resubscribeTopics.hasOwnProperty(topic) ||
                that._resubscribeTopics[topic].qos < opts.qos ||
                resubscribe) {
                var currentOpts = {
                  topic: topic,
                  qos: opts.qos
                }
                if (version === 5) {
                  currentOpts.nl = opts.nl
                  currentOpts.rap = opts.rap
                  currentOpts.rh = opts.rh
                  currentOpts.properties = opts.properties
                }
                debug('subscribe: pushing topic `%s` and qos `%s` to subs list', currentOpts.topic, currentOpts.qos)
                subs.push(currentOpts)
              }
            })
          } else {
            Object
              .keys(obj)
              .forEach(function (k) {
                debug('subscribe: object topic %s', k)
                if (!that._resubscribeTopics.hasOwnProperty(k) ||
                  that._resubscribeTopics[k].qos < obj[k].qos ||
                  resubscribe) {
                  var currentOpts = {
                    topic: k,
                    qos: obj[k].qos
                  }
                  if (version === 5) {
                    currentOpts.nl = obj[k].nl
                    currentOpts.rap = obj[k].rap
                    currentOpts.rh = obj[k].rh
                    currentOpts.properties = opts.properties
                  }
                  debug('subscribe: pushing `%s` to subs list', currentOpts)
                  subs.push(currentOpts)
                }
              })
          }

          packet = {
            cmd: 'subscribe',
            subscriptions: subs,
            qos: 1,
            retain: false,
            dup: false,
            messageId: this._nextId()
          }

          if (opts.properties) {
            packet.properties = opts.properties
          }

          if (!subs.length) {
            callback(null, [])
            return
          }

          // subscriptions to resubscribe to in case of disconnect
          if (this.options.resubscribe) {
            debug('subscribe :: resubscribe true')
            var topics = []
            subs.forEach(function (sub) {
              if (that.options.reconnectPeriod > 0) {
                var topic = { qos: sub.qos }
                if (version === 5) {
                  topic.nl = sub.nl || false
                  topic.rap = sub.rap || false
                  topic.rh = sub.rh || 0
                  topic.properties = sub.properties
                }
                that._resubscribeTopics[sub.topic] = topic
                topics.push(sub.topic)
              }
            })
            that.messageIdToTopic[packet.messageId] = topics
          }

          this.outgoing[packet.messageId] = {
            volatile: true,
            cb: function (err, packet) {
              if (!err) {
                var granted = packet.granted
                for (var i = 0; i < granted.length; i += 1) {
                  subs[i].qos = granted[i]
                }
              }

              callback(err, subs)
            }
          }
          debug('subscribe :: call _sendPacket')
          this._sendPacket(packet)

          return this
        }

        /**
         * unsubscribe - unsubscribe from topic(s)
         *
         * @param {String, Array} topic - topics to unsubscribe from
         * @param {Object} [opts] - optional subscription options, includes:
         *    {Object} properties - properties of unsubscribe packet
         * @param {Function} [callback] - callback fired on unsuback
         * @returns {MqttClient} this - for chaining
         * @api public
         * @example client.unsubscribe('topic');
         * @example client.unsubscribe('topic', console.log);
         */
        MqttClient.prototype.unsubscribe = function () {
          var packet = {
            cmd: 'unsubscribe',
            qos: 1,
            messageId: this._nextId()
          }
          var that = this
          var args = new Array(arguments.length)
          for (var i = 0; i < arguments.length; i++) {
            args[i] = arguments[i]
          }
          var topic = args.shift()
          var callback = args.pop() || nop
          var opts = args.pop()

          if (typeof topic === 'string') {
            topic = [topic]
          }

          if (typeof callback !== 'function') {
            opts = callback
            callback = nop
          }

          if (this._checkDisconnecting(callback)) {
            return this
          }

          if (typeof topic === 'string') {
            packet.unsubscriptions = [topic]
          } else if (Array.isArray(topic)) {
            packet.unsubscriptions = topic
          }

          if (this.options.resubscribe) {
            packet.unsubscriptions.forEach(function (topic) {
              delete that._resubscribeTopics[topic]
            })
          }

          if (typeof opts === 'object' && opts.properties) {
            packet.properties = opts.properties
          }

          this.outgoing[packet.messageId] = {
            volatile: true,
            cb: callback
          }

          debug('unsubscribe: call _sendPacket')
          this._sendPacket(packet)

          return this
        }

        /**
         * end - close connection
         *
         * @returns {MqttClient} this - for chaining
         * @param {Boolean} force - do not wait for all in-flight messages to be acked
         * @param {Function} cb - called when the client has been closed
         *
         * @api public
         */
        MqttClient.prototype.end = function (force, opts, cb) {
          var that = this

          debug('end :: (%s)', this.options.clientId)

          if (force == null || typeof force !== 'boolean') {
            cb = opts || nop
            opts = force
            force = false
            if (typeof opts !== 'object') {
              cb = opts
              opts = null
              if (typeof cb !== 'function') {
                cb = nop
              }
            }
          }

          if (typeof opts !== 'object') {
            cb = opts
            opts = null
          }

          debug('end :: cb? %s', !!cb)
          cb = cb || nop

          function closeStores() {
            debug('end :: closeStores: closing incoming and outgoing stores')
            that.disconnected = true
            that.incomingStore.close(function () {
              that.outgoingStore.close(function () {
                debug('end :: closeStores: emitting end')
                that.emit('end')
                if (cb) {
                  debug('end :: closeStores: invoking callback with args')
                  cb()
                }
              })
            })
            if (that._deferredReconnect) {
              that._deferredReconnect()
            }
          }

          function finish() {
            // defer closesStores of an I/O cycle,
            // just to make sure things are
            // ok for websockets
            debug('end :: (%s) :: finish :: calling _cleanUp with force %s', that.options.clientId, force)
            that._cleanUp(force, () => {
              debug('end :: finish :: calling process.nextTick on closeStores')
              // var boundProcess = process.nextTick.bind(null, closeStores)
              process.nextTick(closeStores.bind(that))
            }, opts)
          }

          if (this.disconnecting) {
            cb()
            return this
          }

          this._clearReconnect()

          this.disconnecting = true

          if (!force && Object.keys(this.outgoing).length > 0) {
            // wait 10ms, just to be sure we received all of it
            debug('end :: (%s) :: calling finish in 10ms once outgoing is empty', that.options.clientId)
            this.once('outgoingEmpty', setTimeout.bind(null, finish, 10))
          } else {
            debug('end :: (%s) :: immediately calling finish', that.options.clientId)
            finish()
          }

          return this
        }

        /**
         * removeOutgoingMessage - remove a message in outgoing store
         * the outgoing callback will be called withe Error('Message removed') if the message is removed
         *
         * @param {Number} messageId - messageId to remove message
         * @returns {MqttClient} this - for chaining
         * @api public
         *
         * @example client.removeOutgoingMessage(client.getLastMessageId());
         */
        MqttClient.prototype.removeOutgoingMessage = function (messageId) {
          var cb = this.outgoing[messageId] ? this.outgoing[messageId].cb : null
          delete this.outgoing[messageId]
          this.outgoingStore.del({ messageId: messageId }, function () {
            cb(new Error('Message removed'))
          })
          return this
        }

        /**
         * reconnect - connect again using the same options as connect()
         *
         * @param {Object} [opts] - optional reconnect options, includes:
         *    {Store} incomingStore - a store for the incoming packets
         *    {Store} outgoingStore - a store for the outgoing packets
         *    if opts is not given, current stores are used
         * @returns {MqttClient} this - for chaining
         *
         * @api public
         */
        MqttClient.prototype.reconnect = function (opts) {
          debug('client reconnect')
          var that = this
          var f = function () {
            if (opts) {
              that.options.incomingStore = opts.incomingStore
              that.options.outgoingStore = opts.outgoingStore
            } else {
              that.options.incomingStore = null
              that.options.outgoingStore = null
            }
            that.incomingStore = that.options.incomingStore || new Store()
            that.outgoingStore = that.options.outgoingStore || new Store()
            that.disconnecting = false
            that.disconnected = false
            that._deferredReconnect = null
            that._reconnect()
          }

          if (this.disconnecting && !this.disconnected) {
            this._deferredReconnect = f
          } else {
            f()
          }
          return this
        }

        /**
         * _reconnect - implement reconnection
         * @api privateish
         */
        MqttClient.prototype._reconnect = function () {
          debug('_reconnect: emitting reconnect to client')
          this.emit('reconnect')
          debug('_reconnect: calling _setupStream')
          this._setupStream()
        }

        /**
         * _setupReconnect - setup reconnect timer
         */
        MqttClient.prototype._setupReconnect = function () {
          var that = this

          if (!that.disconnecting && !that.reconnectTimer && (that.options.reconnectPeriod > 0)) {
            if (!this.reconnecting) {
              debug('_setupReconnect :: emit `offline` state')
              this.emit('offline')
              debug('_setupReconnect :: set `reconnecting` to `true`')
              this.reconnecting = true
            }
            debug('_setupReconnect :: setting reconnectTimer for %d ms', that.options.reconnectPeriod)
            that.reconnectTimer = setInterval(function () {
              debug('reconnectTimer :: reconnect triggered!')
              that._reconnect()
            }, that.options.reconnectPeriod)
          } else {
            debug('_setupReconnect :: doing nothing...')
          }
        }

        /**
         * _clearReconnect - clear the reconnect timer
         */
        MqttClient.prototype._clearReconnect = function () {
          debug('_clearReconnect : clearing reconnect timer')
          if (this.reconnectTimer) {
            clearInterval(this.reconnectTimer)
            this.reconnectTimer = null
          }
        }

        /**
         * _cleanUp - clean up on connection end
         * @api private
         */
        MqttClient.prototype._cleanUp = function (forced, done) {
          var opts = arguments[2]
          if (done) {
            debug('_cleanUp :: done callback provided for on stream close')
            this.stream.on('close', done)
          }

          debug('_cleanUp :: forced? %s', forced)
          if (forced) {
            if ((this.options.reconnectPeriod === 0) && this.options.clean) {
              flush(this.outgoing)
            }
            debug('_cleanUp :: (%s) :: destroying stream', this.options.clientId)
            this.stream.destroy()
          } else {
            var packet = xtend({ cmd: 'disconnect' }, opts)
            debug('_cleanUp :: (%s) :: call _sendPacket with disconnect packet', this.options.clientId)
            this._sendPacket(
              packet,
              setImmediate.bind(
                null,
                this.stream.end.bind(this.stream)
              )
            )
          }

          if (!this.disconnecting) {
            debug('_cleanUp :: client not disconnecting. Clearing and resetting reconnect.')
            this._clearReconnect()
            this._setupReconnect()
          }

          if (this.pingTimer !== null) {
            debug('_cleanUp :: clearing pingTimer')
            this.pingTimer.clear()
            this.pingTimer = null
          }

          if (done && !this.connected) {
            debug('_cleanUp :: (%s) :: removing stream `done` callback `close` listener', this.options.clientId)
            this.stream.removeListener('close', done)
            done()
          }
        }

        /**
         * _sendPacket - send or queue a packet
         * @param {Object} packet - packet options
         * @param {Function} cb - callback when the packet is sent
         * @param {Function} cbStorePut - called when message is put into outgoingStore
         * @api private
         */
        MqttClient.prototype._sendPacket = function (packet, cb, cbStorePut) {
          debug('_sendPacket :: (%s) ::  start', this.options.clientId)
          cbStorePut = cbStorePut || nop

          if (!this.connected) {
            debug('_sendPacket :: client not connected. Storing packet offline.')
            this._storePacket(packet, cb, cbStorePut)
            return
          }

          // When sending a packet, reschedule the ping timer
          this._shiftPingInterval()

          switch (packet.cmd) {
            case 'publish':
              break
            case 'pubrel':
              storeAndSend(this, packet, cb, cbStorePut)
              return
            default:
              sendPacket(this, packet, cb)
              return
          }

          switch (packet.qos) {
            case 2:
            case 1:
              storeAndSend(this, packet, cb, cbStorePut)
              break
            /**
             * no need of case here since it will be caught by default
             * and jshint comply that before default it must be a break
             * anyway it will result in -1 evaluation
             */
            case 0:
            /* falls through */
            default:
              sendPacket(this, packet, cb)
              break
          }
          debug('_sendPacket :: (%s) ::  end', this.options.clientId)
        }

        /**
         * _storePacket - queue a packet
         * @param {Object} packet - packet options
         * @param {Function} cb - callback when the packet is sent
         * @param {Function} cbStorePut - called when message is put into outgoingStore
         * @api private
         */
        MqttClient.prototype._storePacket = function (packet, cb, cbStorePut) {
          debug('_storePacket :: packet: %o', packet)
          debug('_storePacket :: cb? %s', !!cb)
          cbStorePut = cbStorePut || nop

          // check that the packet is not a qos of 0, or that the command is not a publish
          if (((packet.qos || 0) === 0 && this.queueQoSZero) || packet.cmd !== 'publish') {
            this.queue.push({ packet: packet, cb: cb })
          } else if (packet.qos > 0) {
            cb = this.outgoing[packet.messageId] ? this.outgoing[packet.messageId].cb : null
            this.outgoingStore.put(packet, function (err) {
              if (err) {
                return cb && cb(err)
              }
              cbStorePut()
            })
          } else if (cb) {
            cb(new Error('No connection to broker'))
          }
        }

        /**
         * _setupPingTimer - setup the ping timer
         *
         * @api private
         */
        MqttClient.prototype._setupPingTimer = function () {
          debug('_setupPingTimer :: keepalive %d (seconds)', this.options.keepalive)
          var that = this

          if (!this.pingTimer && this.options.keepalive) {
            this.pingResp = true
            this.pingTimer = reInterval(function () {
              that._checkPing()
            }, this.options.keepalive * 1000)
          }
        }

        /**
         * _shiftPingInterval - reschedule the ping interval
         *
         * @api private
         */
        MqttClient.prototype._shiftPingInterval = function () {
          if (this.pingTimer && this.options.keepalive && this.options.reschedulePings) {
            this.pingTimer.reschedule(this.options.keepalive * 1000)
          }
        }
        /**
         * _checkPing - check if a pingresp has come back, and ping the server again
         *
         * @api private
         */
        MqttClient.prototype._checkPing = function () {
          debug('_checkPing :: checking ping...')
          if (this.pingResp) {
            debug('_checkPing :: ping response received. Clearing flag and sending `pingreq`')
            this.pingResp = false
            this._sendPacket({ cmd: 'pingreq' })
          } else {
            // do a forced cleanup since socket will be in bad shape
            debug('_checkPing :: calling _cleanUp with force true')
            this._cleanUp(true)
          }
        }

        /**
         * _handlePingresp - handle a pingresp
         *
         * @api private
         */
        MqttClient.prototype._handlePingresp = function () {
          this.pingResp = true
        }

        /**
         * _handleConnack
         *
         * @param {Object} packet
         * @api private
         */
        MqttClient.prototype._handleConnack = function (packet) {
          debug('_handleConnack')
          var options = this.options
          var version = options.protocolVersion
          var rc = version === 5 ? packet.reasonCode : packet.returnCode

          clearTimeout(this.connackTimer)

          if (packet.properties) {
            if (packet.properties.topicAliasMaximum) {
              if (!options.properties) { options.properties = {} }
              options.properties.topicAliasMaximum = packet.properties.topicAliasMaximum
            }
            if (packet.properties.serverKeepAlive && options.keepalive) {
              options.keepalive = packet.properties.serverKeepAlive
              this._shiftPingInterval()
            }
            if (packet.properties.maximumPacketSize) {
              if (!options.properties) { options.properties = {} }
              options.properties.maximumPacketSize = packet.properties.maximumPacketSize
            }
          }

          if (rc === 0) {
            this.reconnecting = false
            this._onConnect(packet)
          } else if (rc > 0) {
            var err = new Error('Connection refused: ' + errors[rc])
            err.code = rc
            this.emit('error', err)
          }
        }

        /**
         * _handlePublish
         *
         * @param {Object} packet
         * @api private
         */
        /*
        those late 2 case should be rewrite to comply with coding style:
        
        case 1:
        case 0:
          // do not wait sending a puback
          // no callback passed
          if (1 === qos) {
            this._sendPacket({
              cmd: 'puback',
              messageId: messageId
            });
          }
          // emit the message event for both qos 1 and 0
          this.emit('message', topic, message, packet);
          this.handleMessage(packet, done);
          break;
        default:
          // do nothing but every switch mus have a default
          // log or throw an error about unknown qos
          break;
        
        for now i just suppressed the warnings
        */
        MqttClient.prototype._handlePublish = function (packet, done) {
          debug('_handlePublish: packet %o', packet)
          done = typeof done !== 'undefined' ? done : nop
          var topic = packet.topic.toString()
          var message = packet.payload
          var qos = packet.qos
          var messageId = packet.messageId
          var that = this
          var options = this.options
          var validReasonCodes = [0, 16, 128, 131, 135, 144, 145, 151, 153]
          debug('_handlePublish: qos %d', qos)
          switch (qos) {
            case 2: {
              options.customHandleAcks(topic, message, packet, function (error, code) {
                if (!(error instanceof Error)) {
                  code = error
                  error = null
                }
                if (error) { return that.emit('error', error) }
                if (validReasonCodes.indexOf(code) === -1) { return that.emit('error', new Error('Wrong reason code for pubrec')) }
                if (code) {
                  that._sendPacket({ cmd: 'pubrec', messageId: messageId, reasonCode: code }, done)
                } else {
                  that.incomingStore.put(packet, function () {
                    that._sendPacket({ cmd: 'pubrec', messageId: messageId }, done)
                  })
                }
              })
              break
            }
            case 1: {
              // emit the message event
              options.customHandleAcks(topic, message, packet, function (error, code) {
                if (!(error instanceof Error)) {
                  code = error
                  error = null
                }
                if (error) { return that.emit('error', error) }
                if (validReasonCodes.indexOf(code) === -1) { return that.emit('error', new Error('Wrong reason code for puback')) }
                if (!code) { that.emit('message', topic, message, packet) }
                that.handleMessage(packet, function (err) {
                  if (err) {
                    return done && done(err)
                  }
                  that._sendPacket({ cmd: 'puback', messageId: messageId, reasonCode: code }, done)
                })
              })
              break
            }
            case 0:
              // emit the message event
              this.emit('message', topic, message, packet)
              this.handleMessage(packet, done)
              break
            default:
              // do nothing
              debug('_handlePublish: unknown QoS. Doing nothing.')
              // log or throw an error about unknown qos
              break
          }
        }

        /**
         * Handle messages with backpressure support, one at a time.
         * Override at will.
         *
         * @param Packet packet the packet
         * @param Function callback call when finished
         * @api public
         */
        MqttClient.prototype.handleMessage = function (packet, callback) {
          callback()
        }

        /**
         * _handleAck
         *
         * @param {Object} packet
         * @api private
         */

        MqttClient.prototype._handleAck = function (packet) {
          /* eslint no-fallthrough: "off" */
          var messageId = packet.messageId
          var type = packet.cmd
          var response = null
          var cb = this.outgoing[messageId] ? this.outgoing[messageId].cb : null
          var that = this
          var err

          if (!cb) {
            debug('_handleAck :: Server sent an ack in error. Ignoring.')
            // Server sent an ack in error, ignore it.
            return
          }

          // Process
          debug('_handleAck :: packet type', type)
          switch (type) {
            case 'pubcomp':
            // same thing as puback for QoS 2
            case 'puback':
              var pubackRC = packet.reasonCode
              // Callback - we're done
              if (pubackRC && pubackRC > 0 && pubackRC !== 16) {
                err = new Error('Publish error: ' + errors[pubackRC])
                err.code = pubackRC
                cb(err, packet)
              }
              delete this.outgoing[messageId]
              this.outgoingStore.del(packet, cb)
              break
            case 'pubrec':
              response = {
                cmd: 'pubrel',
                qos: 2,
                messageId: messageId
              }
              var pubrecRC = packet.reasonCode

              if (pubrecRC && pubrecRC > 0 && pubrecRC !== 16) {
                err = new Error('Publish error: ' + errors[pubrecRC])
                err.code = pubrecRC
                cb(err, packet)
              } else {
                this._sendPacket(response)
              }
              break
            case 'suback':
              delete this.outgoing[messageId]
              for (var grantedI = 0; grantedI < packet.granted.length; grantedI++) {
                if ((packet.granted[grantedI] & 0x80) !== 0) {
                  // suback with Failure status
                  var topics = this.messageIdToTopic[messageId]
                  if (topics) {
                    topics.forEach(function (topic) {
                      delete that._resubscribeTopics[topic]
                    })
                  }
                }
              }
              cb(null, packet)
              break
            case 'unsuback':
              delete this.outgoing[messageId]
              cb(null)
              break
            default:
              that.emit('error', new Error('unrecognized packet type'))
          }

          if (this.disconnecting &&
            Object.keys(this.outgoing).length === 0) {
            this.emit('outgoingEmpty')
          }
        }

        /**
         * _handlePubrel
         *
         * @param {Object} packet
         * @api private
         */
        MqttClient.prototype._handlePubrel = function (packet, callback) {
          debug('handling pubrel packet')
          callback = typeof callback !== 'undefined' ? callback : nop
          var messageId = packet.messageId
          var that = this

          var comp = { cmd: 'pubcomp', messageId: messageId }

          that.incomingStore.get(packet, function (err, pub) {
            if (!err) {
              that.emit('message', pub.topic, pub.payload, pub)
              that.handleMessage(pub, function (err) {
                if (err) {
                  return callback(err)
                }
                that.incomingStore.del(pub, nop)
                that._sendPacket(comp, callback)
              })
            } else {
              that._sendPacket(comp, callback)
            }
          })
        }

        /**
         * _handleDisconnect
         *
         * @param {Object} packet
         * @api private
         */
        MqttClient.prototype._handleDisconnect = function (packet) {
          this.emit('disconnect', packet)
        }

        /**
         * _nextId
         * @return unsigned int
         */
        MqttClient.prototype._nextId = function () {
          // id becomes current state of this.nextId and increments afterwards
          var id = this.nextId++
          // Ensure 16 bit unsigned int (max 65535, nextId got one higher)
          if (this.nextId === 65536) {
            this.nextId = 1
          }
          return id
        }

        /**
         * getLastMessageId
         * @return unsigned int
         */
        MqttClient.prototype.getLastMessageId = function () {
          return (this.nextId === 1) ? 65535 : (this.nextId - 1)
        }

        /**
         * _resubscribe
         * @api private
         */
        MqttClient.prototype._resubscribe = function (connack) {
          debug('_resubscribe')
          var _resubscribeTopicsKeys = Object.keys(this._resubscribeTopics)
          if (!this._firstConnection &&
            (this.options.clean || (this.options.protocolVersion === 5 && !connack.sessionPresent)) &&
            _resubscribeTopicsKeys.length > 0) {
            if (this.options.resubscribe) {
              if (this.options.protocolVersion === 5) {
                debug('_resubscribe: protocolVersion 5')
                for (var topicI = 0; topicI < _resubscribeTopicsKeys.length; topicI++) {
                  var resubscribeTopic = {}
                  resubscribeTopic[_resubscribeTopicsKeys[topicI]] = this._resubscribeTopics[_resubscribeTopicsKeys[topicI]]
                  resubscribeTopic.resubscribe = true
                  this.subscribe(resubscribeTopic, { properties: resubscribeTopic[_resubscribeTopicsKeys[topicI]].properties })
                }
              } else {
                this._resubscribeTopics.resubscribe = true
                this.subscribe(this._resubscribeTopics)
              }
            } else {
              this._resubscribeTopics = {}
            }
          }

          this._firstConnection = false
        }

        /**
         * _onConnect
         *
         * @api private
         */
        MqttClient.prototype._onConnect = function (packet) {
          if (this.disconnected) {
            this.emit('connect', packet)
            return
          }

          var that = this

          this._setupPingTimer()
          this._resubscribe(packet)

          this.connected = true

          function startStreamProcess() {
            var outStore = that.outgoingStore.createStream()

            function clearStoreProcessing() {
              that._storeProcessing = false
              that._packetIdsDuringStoreProcessing = {}
            }

            that.once('close', remove)
            outStore.on('error', function (err) {
              clearStoreProcessing()
              that.removeListener('close', remove)
              that.emit('error', err)
            })

            function remove() {
              outStore.destroy()
              outStore = null
              clearStoreProcessing()
            }

            function storeDeliver() {
              // edge case, we wrapped this twice
              if (!outStore) {
                return
              }
              that._storeProcessing = true

              var packet = outStore.read(1)

              var cb

              if (!packet) {
                // read when data is available in the future
                outStore.once('readable', storeDeliver)
                return
              }

              // Skip already processed store packets
              if (that._packetIdsDuringStoreProcessing[packet.messageId]) {
                storeDeliver()
                return
              }

              // Avoid unnecessary stream read operations when disconnected
              if (!that.disconnecting && !that.reconnectTimer) {
                cb = that.outgoing[packet.messageId] ? that.outgoing[packet.messageId].cb : null
                that.outgoing[packet.messageId] = {
                  volatile: false,
                  cb: function (err, status) {
                    // Ensure that the original callback passed in to publish gets invoked
                    if (cb) {
                      cb(err, status)
                    }

                    storeDeliver()
                  }
                }
                that._packetIdsDuringStoreProcessing[packet.messageId] = true
                that._sendPacket(packet)
              } else if (outStore.destroy) {
                outStore.destroy()
              }
            }

            outStore.on('end', function () {
              var allProcessed = true
              for (var id in that._packetIdsDuringStoreProcessing) {
                if (!that._packetIdsDuringStoreProcessing[id]) {
                  allProcessed = false
                  break
                }
              }
              if (allProcessed) {
                clearStoreProcessing()
                that.removeListener('close', remove)
                that.emit('connect', packet)
              } else {
                startStreamProcess()
              }
            })
            storeDeliver()
          }
          // start flowing
          startStreamProcess()
        }

        module.exports = MqttClient

      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, { "./store": 7, "./validations": 8, "_process": 100, "debug": 17, "events": 83, "inherits": 88, "mqtt-packet": 92, "readable-stream": 116, "reinterval": 117, "xtend": 140 }], 2: [function (require, module, exports) {
      (function (Buffer) {
        'use strict'

        var Transform = require('readable-stream').Transform
        var duplexify = require('duplexify')
        var base64 = require('base64-js')

        /* global FileReader */
        var my
        var proxy
        var stream
        var isInitialized = false

        function buildProxy() {
          var proxy = new Transform()
          proxy._write = function (chunk, encoding, next) {
            my.sendSocketMessage({
              data: chunk.buffer,
              success: function () {
                next()
              },
              fail: function () {
                next(new Error())
              }
            })
          }
          proxy._flush = function socketEnd(done) {
            my.closeSocket({
              success: function () {
                done()
              }
            })
          }

          return proxy
        }

        function setDefaultOpts(opts) {
          if (!opts.hostname) {
            opts.hostname = 'localhost'
          }
          if (!opts.path) {
            opts.path = '/'
          }

          if (!opts.wsOptions) {
            opts.wsOptions = {}
          }
        }

        function buildUrl(opts, client) {
          var protocol = opts.protocol === 'alis' ? 'wss' : 'ws'
          var url = protocol + '://' + opts.hostname + opts.path
          if (opts.port && opts.port !== 80 && opts.port !== 443) {
            url = protocol + '://' + opts.hostname + ':' + opts.port + opts.path
          }
          if (typeof (opts.transformWsUrl) === 'function') {
            url = opts.transformWsUrl(url, opts, client)
          }
          return url
        }

        function bindEventHandler() {
          if (isInitialized) return

          isInitialized = true

          my.onSocketOpen(function () {
            stream.setReadable(proxy)
            stream.setWritable(proxy)
            stream.emit('connect')
          })

          my.onSocketMessage(function (res) {
            if (typeof res.data === 'string') {
              var array = base64.toByteArray(res.data)
              var buffer = Buffer.from(array)
              proxy.push(buffer)
            } else {
              var reader = new FileReader()
              reader.addEventListener('load', function () {
                var data = reader.result

                if (data instanceof ArrayBuffer) data = Buffer.from(data)
                else data = Buffer.from(data, 'utf8')
                proxy.push(data)
              })
              reader.readAsArrayBuffer(res.data)
            }
          })

          my.onSocketClose(function () {
            stream.end()
            stream.destroy()
          })

          my.onSocketError(function (res) {
            stream.destroy(res)
          })
        }

        function buildStream(client, opts) {
          opts.hostname = opts.hostname || opts.host

          if (!opts.hostname) {
            throw new Error('Could not determine host. Specify host manually.')
          }

          var websocketSubProtocol =
            (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3)
              ? 'mqttv3.1'
              : 'mqtt'

          setDefaultOpts(opts)

          var url = buildUrl(opts, client)
          my = opts.my
          my.connectSocket({
            url: url,
            protocols: websocketSubProtocol
          })

          proxy = buildProxy()
          stream = duplexify.obj()

          bindEventHandler()

          return stream
        }

        module.exports = buildStream

      }).call(this, require("buffer").Buffer)
    }, { "base64-js": 10, "buffer": 12, "duplexify": 19, "readable-stream": 116 }], 3: [function (require, module, exports) {
      'use strict'
      var net = require('net')
      var debug = require('debug')('mqttjs:tcp')

      /*
        variables port and host can be removed since
        you have all required information in opts object
      */
      function streamBuilder(client, opts) {
        var port, host
        opts.port = opts.port || 1883
        opts.hostname = opts.hostname || opts.host || 'localhost'

        port = opts.port
        host = opts.hostname

        debug('port %d and host %s', port, host)
        return net.createConnection(port, host)
      }

      module.exports = streamBuilder

    }, { "debug": 17, "net": 11 }], 4: [function (require, module, exports) {
      'use strict'
      var tls = require('tls')
      var debug = require('debug')('mqttjs:tls')

      function buildBuilder(mqttClient, opts) {
        var connection
        opts.port = opts.port || 8883
        opts.host = opts.hostname || opts.host || 'localhost'
        opts.servername = opts.host

        opts.rejectUnauthorized = opts.rejectUnauthorized !== false

        delete opts.path

        debug('port %d host %s rejectUnauthorized %b', opts.port, opts.host, opts.rejectUnauthorized)

        connection = tls.connect(opts)
        /* eslint no-use-before-define: [2, "nofunc"] */
        connection.on('secureConnect', function () {
          if (opts.rejectUnauthorized && !connection.authorized) {
            connection.emit('error', new Error('TLS not authorized'))
          } else {
            connection.removeListener('error', handleTLSerrors)
          }
        })

        function handleTLSerrors(err) {
          // How can I get verify this error is a tls error?
          if (opts.rejectUnauthorized) {
            mqttClient.emit('error', err)
          }

          // close this connection to match the behaviour of net
          // otherwise all we get is an error from the connection
          // and close event doesn't fire. This is a work around
          // to enable the reconnect code to work the same as with
          // net.createConnection
          connection.end()
        }

        connection.on('error', handleTLSerrors)
        return connection
      }

      module.exports = buildBuilder

    }, { "debug": 17, "tls": 11 }], 5: [function (require, module, exports) {
      (function (process) {
        'use strict'

        var debug = require('debug')('mqttjs:ws')
        var websocket = require('websocket-stream')
        var urlModule = require('url')
        var WSS_OPTIONS = [
          'rejectUnauthorized',
          'ca',
          'cert',
          'key',
          'pfx',
          'passphrase'
        ]
        var IS_BROWSER = process.title === 'browser'

        function buildUrl(opts, client) {
          var url = opts.protocol + '://' + opts.hostname + ':' + opts.port + opts.path
          if (typeof (opts.transformWsUrl) === 'function') {
            url = opts.transformWsUrl(url, opts, client)
          }
          return url
        }

        function setDefaultOpts(opts) {
          if (!opts.hostname) {
            opts.hostname = 'localhost'
          }
          if (!opts.port) {
            if (opts.protocol === 'wss') {
              opts.port = 443
            } else {
              opts.port = 80
            }
          }
          if (!opts.path) {
            opts.path = '/'
          }

          if (!opts.wsOptions) {
            opts.wsOptions = {}
          }
          if (!IS_BROWSER && opts.protocol === 'wss') {
            // Add cert/key/ca etc options
            WSS_OPTIONS.forEach(function (prop) {
              if (opts.hasOwnProperty(prop) && !opts.wsOptions.hasOwnProperty(prop)) {
                opts.wsOptions[prop] = opts[prop]
              }
            })
          }
        }

        function createWebSocket(client, opts) {
          debug('createWebSocket')
          var websocketSubProtocol =
            (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3)
              ? 'mqttv3.1'
              : 'mqtt'

          setDefaultOpts(opts)
          var url = buildUrl(opts, client)
          debug('url %s protocol %s', url, websocketSubProtocol)
          return websocket(url, [websocketSubProtocol], opts.wsOptions)
        }

        function streamBuilder(client, opts) {
          return createWebSocket(client, opts)
        }

        function browserStreamBuilder(client, opts) {
          debug('browserStreamBuilder')
          if (!opts.hostname) {
            opts.hostname = opts.host
          }

          if (!opts.hostname) {
            // Throwing an error in a Web Worker if no `hostname` is given, because we
            // can not determine the `hostname` automatically.  If connecting to
            // localhost, please supply the `hostname` as an argument.
            if (typeof (document) === 'undefined') {
              throw new Error('Could not determine host. Specify host manually.')
            }
            var parsed = urlModule.parse(document.URL)
            opts.hostname = parsed.hostname

            if (!opts.port) {
              opts.port = parsed.port
            }
          }
          return createWebSocket(client, opts)
        }

        if (IS_BROWSER) {
          module.exports = browserStreamBuilder
        } else {
          module.exports = streamBuilder
        }

      }).call(this, require('_process'))
    }, { "_process": 100, "debug": 17, "url": 132, "websocket-stream": 137 }], 6: [function (require, module, exports) {
      (function (process, Buffer) {
        'use strict'

        var Transform = require('readable-stream').Transform
        var duplexify = require('duplexify')

        /* global wx */
        var socketTask
        var proxy
        var stream

        function buildProxy() {
          var proxy = new Transform()
          proxy._write = function (chunk, encoding, next) {
            socketTask.send({
              data: chunk.buffer,
              success: function () {
                next()
              },
              fail: function (errMsg) {
                next(new Error(errMsg))
              }
            })
          }
          proxy._flush = function socketEnd(done) {
            socketTask.close({
              success: function () {
                done()
              }
            })
          }

          return proxy
        }

        function setDefaultOpts(opts) {
          if (!opts.hostname) {
            opts.hostname = 'localhost'
          }
          if (!opts.path) {
            opts.path = '/'
          }

          if (!opts.wsOptions) {
            opts.wsOptions = {}
          }
        }

        function buildUrl(opts, client) {
          var protocol = opts.protocol === 'wxs' ? 'wss' : 'ws'
          var url = protocol + '://' + opts.hostname + opts.path
          if (opts.port && opts.port !== 80 && opts.port !== 443) {
            url = protocol + '://' + opts.hostname + ':' + opts.port + opts.path
          }
          if (typeof (opts.transformWsUrl) === 'function') {
            url = opts.transformWsUrl(url, opts, client)
          }
          return url
        }

        function bindEventHandler() {
          socketTask.onOpen(function () {
            stream.setReadable(proxy)
            stream.setWritable(proxy)
            stream.emit('connect')
          })

          socketTask.onMessage(function (res) {
            var data = res.data

            if (data instanceof ArrayBuffer) data = Buffer.from(data)
            else data = Buffer.from(data, 'utf8')
            proxy.push(data)
          })

          socketTask.onClose(function () {
            stream.end()
            stream.destroy()
          })

          socketTask.onError(function (res) {
            stream.destroy(new Error(res.errMsg))
          })
        }

        function buildStream(client, opts) {
          opts.hostname = opts.hostname || opts.host

          if (!opts.hostname) {
            throw new Error('Could not determine host. Specify host manually.')
          }

          var websocketSubProtocol =
            (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3)
              ? 'mqttv3.1'
              : 'mqtt'

          setDefaultOpts(opts)

          var url = buildUrl(opts, client)
          socketTask = wx.connectSocket({
            url: url,
            protocols: [websocketSubProtocol]
          })

          proxy = buildProxy()
          stream = duplexify.obj()
          stream._destroy = function (err, cb) {
            socketTask.close({
              success: function () {
                cb && cb(err)
              }
            })
          }

          var destroyRef = stream.destroy
          stream.destroy = function () {
            stream.destroy = destroyRef

            var self = this
            process.nextTick(function () {
              socketTask.close({
                fail: function () {
                  self._destroy(new Error())
                }
              })
            })
          }.bind(stream)

          bindEventHandler()

          return stream
        }

        module.exports = buildStream

      }).call(this, require('_process'), require("buffer").Buffer)
    }, { "_process": 100, "buffer": 12, "duplexify": 19, "readable-stream": 116 }], 7: [function (require, module, exports) {
      (function (process) {
        'use strict'

        /**
         * Module dependencies
         */
        var xtend = require('xtend')

        var Readable = require('readable-stream').Readable
        var streamsOpts = { objectMode: true }
        var defaultStoreOptions = {
          clean: true
        }

        /**
         * es6-map can preserve insertion order even if ES version is older.
         *
         * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Description
         * It should be noted that a Map which is a map of an object, especially
         * a dictionary of dictionaries, will only map to the object's insertion
         * order. In ES2015 this is ordered for objects but for older versions of
         * ES, this may be random and not ordered.
         *
         */
        var Map = require('es6-map')

        /**
         * In-memory implementation of the message store
         * This can actually be saved into files.
         *
         * @param {Object} [options] - store options
         */
        function Store(options) {
          if (!(this instanceof Store)) {
            return new Store(options)
          }

          this.options = options || {}

          // Defaults
          this.options = xtend(defaultStoreOptions, options)

          this._inflights = new Map()
        }

        /**
         * Adds a packet to the store, a packet is
         * anything that has a messageId property.
         *
         */
        Store.prototype.put = function (packet, cb) {
          this._inflights.set(packet.messageId, packet)

          if (cb) {
            cb()
          }

          return this
        }

        /**
         * Creates a stream with all the packets in the store
         *
         */
        Store.prototype.createStream = function () {
          var stream = new Readable(streamsOpts)
          var destroyed = false
          var values = []
          var i = 0

          this._inflights.forEach(function (value, key) {
            values.push(value)
          })

          stream._read = function () {
            if (!destroyed && i < values.length) {
              this.push(values[i++])
            } else {
              this.push(null)
            }
          }

          stream.destroy = function () {
            if (destroyed) {
              return
            }

            var self = this

            destroyed = true

            process.nextTick(function () {
              self.emit('close')
            })
          }

          return stream
        }

        /**
         * deletes a packet from the store.
         */
        Store.prototype.del = function (packet, cb) {
          packet = this._inflights.get(packet.messageId)
          if (packet) {
            this._inflights.delete(packet.messageId)
            cb(null, packet)
          } else if (cb) {
            cb(new Error('missing packet'))
          }

          return this
        }

        /**
         * get a packet from the store.
         */
        Store.prototype.get = function (packet, cb) {
          packet = this._inflights.get(packet.messageId)
          if (packet) {
            cb(null, packet)
          } else if (cb) {
            cb(new Error('missing packet'))
          }

          return this
        }

        /**
         * Close the store
         */
        Store.prototype.close = function (cb) {
          if (this.options.clean) {
            this._inflights = null
          }
          if (cb) {
            cb()
          }
        }

        module.exports = Store

      }).call(this, require('_process'))
    }, { "_process": 100, "es6-map": 68, "readable-stream": 116, "xtend": 140 }], 8: [function (require, module, exports) {
      'use strict'

      /**
       * Validate a topic to see if it's valid or not.
       * A topic is valid if it follow below rules:
       * - Rule #1: If any part of the topic is not `+` or `#`, then it must not contain `+` and '#'
       * - Rule #2: Part `#` must be located at the end of the mailbox
       *
       * @param {String} topic - A topic
       * @returns {Boolean} If the topic is valid, returns true. Otherwise, returns false.
       */
      function validateTopic(topic) {
        var parts = topic.split('/')

        for (var i = 0; i < parts.length; i++) {
          if (parts[i] === '+') {
            continue
          }

          if (parts[i] === '#') {
            // for Rule #2
            return i === parts.length - 1
          }

          if (parts[i].indexOf('+') !== -1 || parts[i].indexOf('#') !== -1) {
            return false
          }
        }

        return true
      }

      /**
       * Validate an array of topics to see if any of them is valid or not
        * @param {Array} topics - Array of topics
       * @returns {String} If the topics is valid, returns null. Otherwise, returns the invalid one
       */
      function validateTopics(topics) {
        if (topics.length === 0) {
          return 'empty_topic_list'
        }
        for (var i = 0; i < topics.length; i++) {
          if (!validateTopic(topics[i])) {
            return topics[i]
          }
        }
        return null
      }

      module.exports = {
        validateTopics: validateTopics
      }

    }, {}], 9: [function (require, module, exports) {
      (function (process) {
        'use strict'

        var MqttClient = require('../client')
        var Store = require('../store')
        var url = require('url')
        var xtend = require('xtend')
        var debug = require('debug')('mqttjs')

        var protocols = {}

        if (process.title !== 'browser') {
          protocols.mqtt = require('./tcp')
          protocols.tcp = require('./tcp')
          protocols.ssl = require('./tls')
          protocols.tls = require('./tls')
          protocols.mqtts = require('./tls')
        } else {
          protocols.wx = require('./wx')
          protocols.wxs = require('./wx')

          protocols.ali = require('./ali')
          protocols.alis = require('./ali')
        }

        protocols.ws = require('./ws')
        protocols.wss = require('./ws')

        /**
         * Parse the auth attribute and merge username and password in the options object.
         *
         * @param {Object} [opts] option object
         */
        function parseAuthOptions(opts) {
          var matches
          if (opts.auth) {
            matches = opts.auth.match(/^(.+):(.+)$/)
            if (matches) {
              opts.username = matches[1]
              opts.password = matches[2]
            } else {
              opts.username = opts.auth
            }
          }
        }

        /**
         * connect - connect to an MQTT broker.
         *
         * @param {String} [brokerUrl] - url of the broker, optional
         * @param {Object} opts - see MqttClient#constructor
         */
        function connect(brokerUrl, opts) {
          debug('connecting to an MQTT broker...')
          if ((typeof brokerUrl === 'object') && !opts) {
            opts = brokerUrl
            brokerUrl = null
          }

          opts = opts || {}

          if (brokerUrl) {
            var parsed = url.parse(brokerUrl, true)
            if (parsed.port != null) {
              parsed.port = Number(parsed.port)
            }

            opts = xtend(parsed, opts)

            if (opts.protocol === null) {
              throw new Error('Missing protocol')
            }
            opts.protocol = opts.protocol.replace(/:$/, '')
          }

          // merge in the auth options if supplied
          parseAuthOptions(opts)

          // support clientId passed in the query string of the url
          if (opts.query && typeof opts.query.clientId === 'string') {
            opts.clientId = opts.query.clientId
          }

          if (opts.cert && opts.key) {
            if (opts.protocol) {
              if (['mqtts', 'wss', 'wxs', 'alis'].indexOf(opts.protocol) === -1) {
                switch (opts.protocol) {
                  case 'mqtt':
                    opts.protocol = 'mqtts'
                    break
                  case 'ws':
                    opts.protocol = 'wss'
                    break
                  case 'wx':
                    opts.protocol = 'wxs'
                    break
                  case 'ali':
                    opts.protocol = 'alis'
                    break
                  default:
                    throw new Error('Unknown protocol for secure connection: "' + opts.protocol + '"!')
                }
              }
            } else {
              // A cert and key was provided, however no protocol was specified, so we will throw an error.
              throw new Error('Missing secure protocol key')
            }
          }

          if (!protocols[opts.protocol]) {
            var isSecure = ['mqtts', 'wss'].indexOf(opts.protocol) !== -1
            opts.protocol = [
              'mqtt',
              'mqtts',
              'ws',
              'wss',
              'wx',
              'wxs',
              'ali',
              'alis'
            ].filter(function (key, index) {
              if (isSecure && index % 2 === 0) {
                // Skip insecure protocols when requesting a secure one.
                return false
              }
              return (typeof protocols[key] === 'function')
            })[0]
          }

          if (opts.clean === false && !opts.clientId) {
            throw new Error('Missing clientId for unclean clients')
          }

          if (opts.protocol) {
            opts.defaultProtocol = opts.protocol
          }

          function wrapper(client) {
            if (opts.servers) {
              if (!client._reconnectCount || client._reconnectCount === opts.servers.length) {
                client._reconnectCount = 0
              }

              opts.host = opts.servers[client._reconnectCount].host
              opts.port = opts.servers[client._reconnectCount].port
              opts.protocol = (!opts.servers[client._reconnectCount].protocol ? opts.defaultProtocol : opts.servers[client._reconnectCount].protocol)
              opts.hostname = opts.host

              client._reconnectCount++
            }

            debug('calling streambuilder for', opts.protocol)
            return protocols[opts.protocol](client, opts)
          }
          var client = new MqttClient(wrapper, opts)
          client.on('error', function () { /* Automatically set up client error handling */ })
          return client
        }

        module.exports = connect
        module.exports.connect = connect
        module.exports.MqttClient = MqttClient
        module.exports.Store = Store

      }).call(this, require('_process'))
    }, { "../client": 1, "../store": 7, "./ali": 2, "./tcp": 3, "./tls": 4, "./ws": 5, "./wx": 6, "_process": 100, "debug": 17, "url": 132, "xtend": 140 }], 10: [function (require, module, exports) {
      'use strict'

      exports.byteLength = byteLength
      exports.toByteArray = toByteArray
      exports.fromByteArray = fromByteArray

      var lookup = []
      var revLookup = []
      var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

      var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
      for (var i = 0, len = code.length; i < len; ++i) {
        lookup[i] = code[i]
        revLookup[code.charCodeAt(i)] = i
      }

      // Support decoding URL-safe base64 strings, as Node.js does.
      // See: https://en.wikipedia.org/wiki/Base64#URL_applications
      revLookup['-'.charCodeAt(0)] = 62
      revLookup['_'.charCodeAt(0)] = 63

      function getLens(b64) {
        var len = b64.length

        if (len % 4 > 0) {
          throw new Error('Invalid string. Length must be a multiple of 4')
        }

        // Trim off extra bytes after placeholder bytes are found
        // See: https://github.com/beatgammit/base64-js/issues/42
        var validLen = b64.indexOf('=')
        if (validLen === -1) validLen = len

        var placeHoldersLen = validLen === len
          ? 0
          : 4 - (validLen % 4)

        return [validLen, placeHoldersLen]
      }

      // base64 is 4/3 + up to two characters of the original data
      function byteLength(b64) {
        var lens = getLens(b64)
        var validLen = lens[0]
        var placeHoldersLen = lens[1]
        return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
      }

      function _byteLength(b64, validLen, placeHoldersLen) {
        return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
      }

      function toByteArray(b64) {
        var tmp
        var lens = getLens(b64)
        var validLen = lens[0]
        var placeHoldersLen = lens[1]

        var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

        var curByte = 0

        // if there are placeholders, only get up to the last complete 4 chars
        var len = placeHoldersLen > 0
          ? validLen - 4
          : validLen

        for (var i = 0; i < len; i += 4) {
          tmp =
            (revLookup[b64.charCodeAt(i)] << 18) |
            (revLookup[b64.charCodeAt(i + 1)] << 12) |
            (revLookup[b64.charCodeAt(i + 2)] << 6) |
            revLookup[b64.charCodeAt(i + 3)]
          arr[curByte++] = (tmp >> 16) & 0xFF
          arr[curByte++] = (tmp >> 8) & 0xFF
          arr[curByte++] = tmp & 0xFF
        }

        if (placeHoldersLen === 2) {
          tmp =
            (revLookup[b64.charCodeAt(i)] << 2) |
            (revLookup[b64.charCodeAt(i + 1)] >> 4)
          arr[curByte++] = tmp & 0xFF
        }

        if (placeHoldersLen === 1) {
          tmp =
            (revLookup[b64.charCodeAt(i)] << 10) |
            (revLookup[b64.charCodeAt(i + 1)] << 4) |
            (revLookup[b64.charCodeAt(i + 2)] >> 2)
          arr[curByte++] = (tmp >> 8) & 0xFF
          arr[curByte++] = tmp & 0xFF
        }

        return arr
      }

      function tripletToBase64(num) {
        return lookup[num >> 18 & 0x3F] +
          lookup[num >> 12 & 0x3F] +
          lookup[num >> 6 & 0x3F] +
          lookup[num & 0x3F]
      }

      function encodeChunk(uint8, start, end) {
        var tmp
        var output = []
        for (var i = start; i < end; i += 3) {
          tmp =
            ((uint8[i] << 16) & 0xFF0000) +
            ((uint8[i + 1] << 8) & 0xFF00) +
            (uint8[i + 2] & 0xFF)
          output.push(tripletToBase64(tmp))
        }
        return output.join('')
      }

      function fromByteArray(uint8) {
        var tmp
        var len = uint8.length
        var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
        var parts = []
        var maxChunkLength = 16383 // must be multiple of 3

        // go through the array every three bytes, we'll deal with trailing stuff later
        for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
          parts.push(encodeChunk(
            uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
          ))
        }

        // pad the end with zeros, but make sure to not forget the extra bytes
        if (extraBytes === 1) {
          tmp = uint8[len - 1]
          parts.push(
            lookup[tmp >> 2] +
            lookup[(tmp << 4) & 0x3F] +
            '=='
          )
        } else if (extraBytes === 2) {
          tmp = (uint8[len - 2] << 8) + uint8[len - 1]
          parts.push(
            lookup[tmp >> 10] +
            lookup[(tmp >> 4) & 0x3F] +
            lookup[(tmp << 2) & 0x3F] +
            '='
          )
        }

        return parts.join('')
      }

    }, {}], 11: [function (require, module, exports) {

    }, {}], 12: [function (require, module, exports) {
      (function (Buffer) {
        /*!
         * The buffer module from node.js, for the browser.
         *
         * @author   Feross Aboukhadijeh <https://feross.org>
         * @license  MIT
         */
        /* eslint-disable no-proto */

        'use strict'

        var base64 = require('base64-js')
        var ieee754 = require('ieee754')

        exports.Buffer = Buffer
        exports.SlowBuffer = SlowBuffer
        exports.INSPECT_MAX_BYTES = 50

        var K_MAX_LENGTH = 0x7fffffff
        exports.kMaxLength = K_MAX_LENGTH

        /**
         * If `Buffer.TYPED_ARRAY_SUPPORT`:
         *   === true    Use Uint8Array implementation (fastest)
         *   === false   Print warning and recommend using `buffer` v4.x which has an Object
         *               implementation (most compatible, even IE6)
         *
         * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
         * Opera 11.6+, iOS 4.2+.
         *
         * We report that the browser does not support typed arrays if the are not subclassable
         * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
         * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
         * for __proto__ and has a buggy typed array implementation.
         */
        Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()

        if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
          typeof console.error === 'function') {
          console.error(
            'This browser lacks typed array (Uint8Array) support which is required by ' +
            '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
          )
        }

        function typedArraySupport() {
          // Can typed array instances can be augmented?
          try {
            var arr = new Uint8Array(1)
            arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
            return arr.foo() === 42
          } catch (e) {
            return false
          }
        }

        Object.defineProperty(Buffer.prototype, 'parent', {
          enumerable: true,
          get: function () {
            if (!Buffer.isBuffer(this)) return undefined
            return this.buffer
          }
        })

        Object.defineProperty(Buffer.prototype, 'offset', {
          enumerable: true,
          get: function () {
            if (!Buffer.isBuffer(this)) return undefined
            return this.byteOffset
          }
        })

        function createBuffer(length) {
          if (length > K_MAX_LENGTH) {
            throw new RangeError('The value "' + length + '" is invalid for option "size"')
          }
          // Return an augmented `Uint8Array` instance
          var buf = new Uint8Array(length)
          buf.__proto__ = Buffer.prototype
          return buf
        }

        /**
         * The Buffer constructor returns instances of `Uint8Array` that have their
         * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
         * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
         * and the `Uint8Array` methods. Square bracket notation works as expected -- it
         * returns a single octet.
         *
         * The `Uint8Array` prototype remains unmodified.
         */

        function Buffer(arg, encodingOrOffset, length) {
          // Common case.
          if (typeof arg === 'number') {
            if (typeof encodingOrOffset === 'string') {
              throw new TypeError(
                'The "string" argument must be of type string. Received type number'
              )
            }
            return allocUnsafe(arg)
          }
          return from(arg, encodingOrOffset, length)
        }

        // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
        if (typeof Symbol !== 'undefined' && Symbol.species != null &&
          Buffer[Symbol.species] === Buffer) {
          Object.defineProperty(Buffer, Symbol.species, {
            value: null,
            configurable: true,
            enumerable: false,
            writable: false
          })
        }

        Buffer.poolSize = 8192 // not used by this implementation

        function from(value, encodingOrOffset, length) {
          if (typeof value === 'string') {
            return fromString(value, encodingOrOffset)
          }

          if (ArrayBuffer.isView(value)) {
            return fromArrayLike(value)
          }

          if (value == null) {
            throw TypeError(
              'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
              'or Array-like Object. Received type ' + (typeof value)
            )
          }

          if (isInstance(value, ArrayBuffer) ||
            (value && isInstance(value.buffer, ArrayBuffer))) {
            return fromArrayBuffer(value, encodingOrOffset, length)
          }

          if (typeof value === 'number') {
            throw new TypeError(
              'The "value" argument must not be of type number. Received type number'
            )
          }

          var valueOf = value.valueOf && value.valueOf()
          if (valueOf != null && valueOf !== value) {
            return Buffer.from(valueOf, encodingOrOffset, length)
          }

          var b = fromObject(value)
          if (b) return b

          if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
            typeof value[Symbol.toPrimitive] === 'function') {
            return Buffer.from(
              value[Symbol.toPrimitive]('string'), encodingOrOffset, length
            )
          }

          throw new TypeError(
            'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
            'or Array-like Object. Received type ' + (typeof value)
          )
        }

        /**
         * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
         * if value is a number.
         * Buffer.from(str[, encoding])
         * Buffer.from(array)
         * Buffer.from(buffer)
         * Buffer.from(arrayBuffer[, byteOffset[, length]])
         **/
        Buffer.from = function (value, encodingOrOffset, length) {
          return from(value, encodingOrOffset, length)
        }

        // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
        // https://github.com/feross/buffer/pull/148
        Buffer.prototype.__proto__ = Uint8Array.prototype
        Buffer.__proto__ = Uint8Array

        function assertSize(size) {
          if (typeof size !== 'number') {
            throw new TypeError('"size" argument must be of type number')
          } else if (size < 0) {
            throw new RangeError('The value "' + size + '" is invalid for option "size"')
          }
        }

        function alloc(size, fill, encoding) {
          assertSize(size)
          if (size <= 0) {
            return createBuffer(size)
          }
          if (fill !== undefined) {
            // Only pay attention to encoding if it's a string. This
            // prevents accidentally sending in a number that would
            // be interpretted as a start offset.
            return typeof encoding === 'string'
              ? createBuffer(size).fill(fill, encoding)
              : createBuffer(size).fill(fill)
          }
          return createBuffer(size)
        }

        /**
         * Creates a new filled Buffer instance.
         * alloc(size[, fill[, encoding]])
         **/
        Buffer.alloc = function (size, fill, encoding) {
          return alloc(size, fill, encoding)
        }

        function allocUnsafe(size) {
          assertSize(size)
          return createBuffer(size < 0 ? 0 : checked(size) | 0)
        }

        /**
         * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
         * */
        Buffer.allocUnsafe = function (size) {
          return allocUnsafe(size)
        }
        /**
         * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
         */
        Buffer.allocUnsafeSlow = function (size) {
          return allocUnsafe(size)
        }

        function fromString(string, encoding) {
          if (typeof encoding !== 'string' || encoding === '') {
            encoding = 'utf8'
          }

          if (!Buffer.isEncoding(encoding)) {
            throw new TypeError('Unknown encoding: ' + encoding)
          }

          var length = byteLength(string, encoding) | 0
          var buf = createBuffer(length)

          var actual = buf.write(string, encoding)

          if (actual !== length) {
            // Writing a hex string, for example, that contains invalid characters will
            // cause everything after the first invalid character to be ignored. (e.g.
            // 'abxxcd' will be treated as 'ab')
            buf = buf.slice(0, actual)
          }

          return buf
        }

        function fromArrayLike(array) {
          var length = array.length < 0 ? 0 : checked(array.length) | 0
          var buf = createBuffer(length)
          for (var i = 0; i < length; i += 1) {
            buf[i] = array[i] & 255
          }
          return buf
        }

        function fromArrayBuffer(array, byteOffset, length) {
          if (byteOffset < 0 || array.byteLength < byteOffset) {
            throw new RangeError('"offset" is outside of buffer bounds')
          }

          if (array.byteLength < byteOffset + (length || 0)) {
            throw new RangeError('"length" is outside of buffer bounds')
          }

          var buf
          if (byteOffset === undefined && length === undefined) {
            buf = new Uint8Array(array)
          } else if (length === undefined) {
            buf = new Uint8Array(array, byteOffset)
          } else {
            buf = new Uint8Array(array, byteOffset, length)
          }

          // Return an augmented `Uint8Array` instance
          buf.__proto__ = Buffer.prototype
          return buf
        }

        function fromObject(obj) {
          if (Buffer.isBuffer(obj)) {
            var len = checked(obj.length) | 0
            var buf = createBuffer(len)

            if (buf.length === 0) {
              return buf
            }

            obj.copy(buf, 0, 0, len)
            return buf
          }

          if (obj.length !== undefined) {
            if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
              return createBuffer(0)
            }
            return fromArrayLike(obj)
          }

          if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
            return fromArrayLike(obj.data)
          }
        }

        function checked(length) {
          // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
          // length is NaN (which is otherwise coerced to zero.)
          if (length >= K_MAX_LENGTH) {
            throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
              'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
          }
          return length | 0
        }

        function SlowBuffer(length) {
          if (+length != length) { // eslint-disable-line eqeqeq
            length = 0
          }
          return Buffer.alloc(+length)
        }

        Buffer.isBuffer = function isBuffer(b) {
          return b != null && b._isBuffer === true &&
            b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
        }

        Buffer.compare = function compare(a, b) {
          if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
          if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
          if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
            throw new TypeError(
              'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
            )
          }

          if (a === b) return 0

          var x = a.length
          var y = b.length

          for (var i = 0, len = Math.min(x, y); i < len; ++i) {
            if (a[i] !== b[i]) {
              x = a[i]
              y = b[i]
              break
            }
          }

          if (x < y) return -1
          if (y < x) return 1
          return 0
        }

        Buffer.isEncoding = function isEncoding(encoding) {
          switch (String(encoding).toLowerCase()) {
            case 'hex':
            case 'utf8':
            case 'utf-8':
            case 'ascii':
            case 'latin1':
            case 'binary':
            case 'base64':
            case 'ucs2':
            case 'ucs-2':
            case 'utf16le':
            case 'utf-16le':
              return true
            default:
              return false
          }
        }

        Buffer.concat = function concat(list, length) {
          if (!Array.isArray(list)) {
            throw new TypeError('"list" argument must be an Array of Buffers')
          }

          if (list.length === 0) {
            return Buffer.alloc(0)
          }

          var i
          if (length === undefined) {
            length = 0
            for (i = 0; i < list.length; ++i) {
              length += list[i].length
            }
          }

          var buffer = Buffer.allocUnsafe(length)
          var pos = 0
          for (i = 0; i < list.length; ++i) {
            var buf = list[i]
            if (isInstance(buf, Uint8Array)) {
              buf = Buffer.from(buf)
            }
            if (!Buffer.isBuffer(buf)) {
              throw new TypeError('"list" argument must be an Array of Buffers')
            }
            buf.copy(buffer, pos)
            pos += buf.length
          }
          return buffer
        }

        function byteLength(string, encoding) {
          if (Buffer.isBuffer(string)) {
            return string.length
          }
          if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
            return string.byteLength
          }
          if (typeof string !== 'string') {
            throw new TypeError(
              'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
              'Received type ' + typeof string
            )
          }

          var len = string.length
          var mustMatch = (arguments.length > 2 && arguments[2] === true)
          if (!mustMatch && len === 0) return 0

          // Use a for loop to avoid recursion
          var loweredCase = false
          for (; ;) {
            switch (encoding) {
              case 'ascii':
              case 'latin1':
              case 'binary':
                return len
              case 'utf8':
              case 'utf-8':
                return utf8ToBytes(string).length
              case 'ucs2':
              case 'ucs-2':
              case 'utf16le':
              case 'utf-16le':
                return len * 2
              case 'hex':
                return len >>> 1
              case 'base64':
                return base64ToBytes(string).length
              default:
                if (loweredCase) {
                  return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
                }
                encoding = ('' + encoding).toLowerCase()
                loweredCase = true
            }
          }
        }
        Buffer.byteLength = byteLength

        function slowToString(encoding, start, end) {
          var loweredCase = false

          // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
          // property of a typed array.

          // This behaves neither like String nor Uint8Array in that we set start/end
          // to their upper/lower bounds if the value passed is out of range.
          // undefined is handled specially as per ECMA-262 6th Edition,
          // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
          if (start === undefined || start < 0) {
            start = 0
          }
          // Return early if start > this.length. Done here to prevent potential uint32
          // coercion fail below.
          if (start > this.length) {
            return ''
          }

          if (end === undefined || end > this.length) {
            end = this.length
          }

          if (end <= 0) {
            return ''
          }

          // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
          end >>>= 0
          start >>>= 0

          if (end <= start) {
            return ''
          }

          if (!encoding) encoding = 'utf8'

          while (true) {
            switch (encoding) {
              case 'hex':
                return hexSlice(this, start, end)

              case 'utf8':
              case 'utf-8':
                return utf8Slice(this, start, end)

              case 'ascii':
                return asciiSlice(this, start, end)

              case 'latin1':
              case 'binary':
                return latin1Slice(this, start, end)

              case 'base64':
                return base64Slice(this, start, end)

              case 'ucs2':
              case 'ucs-2':
              case 'utf16le':
              case 'utf-16le':
                return utf16leSlice(this, start, end)

              default:
                if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                encoding = (encoding + '').toLowerCase()
                loweredCase = true
            }
          }
        }

        // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
        // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
        // reliably in a browserify context because there could be multiple different
        // copies of the 'buffer' package in use. This method works even for Buffer
        // instances that were created from another copy of the `buffer` package.
        // See: https://github.com/feross/buffer/issues/154
        Buffer.prototype._isBuffer = true

        function swap(b, n, m) {
          var i = b[n]
          b[n] = b[m]
          b[m] = i
        }

        Buffer.prototype.swap16 = function swap16() {
          var len = this.length
          if (len % 2 !== 0) {
            throw new RangeError('Buffer size must be a multiple of 16-bits')
          }
          for (var i = 0; i < len; i += 2) {
            swap(this, i, i + 1)
          }
          return this
        }

        Buffer.prototype.swap32 = function swap32() {
          var len = this.length
          if (len % 4 !== 0) {
            throw new RangeError('Buffer size must be a multiple of 32-bits')
          }
          for (var i = 0; i < len; i += 4) {
            swap(this, i, i + 3)
            swap(this, i + 1, i + 2)
          }
          return this
        }

        Buffer.prototype.swap64 = function swap64() {
          var len = this.length
          if (len % 8 !== 0) {
            throw new RangeError('Buffer size must be a multiple of 64-bits')
          }
          for (var i = 0; i < len; i += 8) {
            swap(this, i, i + 7)
            swap(this, i + 1, i + 6)
            swap(this, i + 2, i + 5)
            swap(this, i + 3, i + 4)
          }
          return this
        }

        Buffer.prototype.toString = function toString() {
          var length = this.length
          if (length === 0) return ''
          if (arguments.length === 0) return utf8Slice(this, 0, length)
          return slowToString.apply(this, arguments)
        }

        Buffer.prototype.toLocaleString = Buffer.prototype.toString

        Buffer.prototype.equals = function equals(b) {
          if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
          if (this === b) return true
          return Buffer.compare(this, b) === 0
        }

        Buffer.prototype.inspect = function inspect() {
          var str = ''
          var max = exports.INSPECT_MAX_BYTES
          str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
          if (this.length > max) str += ' ... '
          return '<Buffer ' + str + '>'
        }

        Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
          if (isInstance(target, Uint8Array)) {
            target = Buffer.from(target, target.offset, target.byteLength)
          }
          if (!Buffer.isBuffer(target)) {
            throw new TypeError(
              'The "target" argument must be one of type Buffer or Uint8Array. ' +
              'Received type ' + (typeof target)
            )
          }

          if (start === undefined) {
            start = 0
          }
          if (end === undefined) {
            end = target ? target.length : 0
          }
          if (thisStart === undefined) {
            thisStart = 0
          }
          if (thisEnd === undefined) {
            thisEnd = this.length
          }

          if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
            throw new RangeError('out of range index')
          }

          if (thisStart >= thisEnd && start >= end) {
            return 0
          }
          if (thisStart >= thisEnd) {
            return -1
          }
          if (start >= end) {
            return 1
          }

          start >>>= 0
          end >>>= 0
          thisStart >>>= 0
          thisEnd >>>= 0

          if (this === target) return 0

          var x = thisEnd - thisStart
          var y = end - start
          var len = Math.min(x, y)

          var thisCopy = this.slice(thisStart, thisEnd)
          var targetCopy = target.slice(start, end)

          for (var i = 0; i < len; ++i) {
            if (thisCopy[i] !== targetCopy[i]) {
              x = thisCopy[i]
              y = targetCopy[i]
              break
            }
          }

          if (x < y) return -1
          if (y < x) return 1
          return 0
        }

        // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
        // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
        //
        // Arguments:
        // - buffer - a Buffer to search
        // - val - a string, Buffer, or number
        // - byteOffset - an index into `buffer`; will be clamped to an int32
        // - encoding - an optional encoding, relevant is val is a string
        // - dir - true for indexOf, false for lastIndexOf
        function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
          // Empty buffer means no match
          if (buffer.length === 0) return -1

          // Normalize byteOffset
          if (typeof byteOffset === 'string') {
            encoding = byteOffset
            byteOffset = 0
          } else if (byteOffset > 0x7fffffff) {
            byteOffset = 0x7fffffff
          } else if (byteOffset < -0x80000000) {
            byteOffset = -0x80000000
          }
          byteOffset = +byteOffset // Coerce to Number.
          if (numberIsNaN(byteOffset)) {
            // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
            byteOffset = dir ? 0 : (buffer.length - 1)
          }

          // Normalize byteOffset: negative offsets start from the end of the buffer
          if (byteOffset < 0) byteOffset = buffer.length + byteOffset
          if (byteOffset >= buffer.length) {
            if (dir) return -1
            else byteOffset = buffer.length - 1
          } else if (byteOffset < 0) {
            if (dir) byteOffset = 0
            else return -1
          }

          // Normalize val
          if (typeof val === 'string') {
            val = Buffer.from(val, encoding)
          }

          // Finally, search either indexOf (if dir is true) or lastIndexOf
          if (Buffer.isBuffer(val)) {
            // Special case: looking for empty string/buffer always fails
            if (val.length === 0) {
              return -1
            }
            return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
          } else if (typeof val === 'number') {
            val = val & 0xFF // Search for a byte value [0-255]
            if (typeof Uint8Array.prototype.indexOf === 'function') {
              if (dir) {
                return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
              } else {
                return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
              }
            }
            return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
          }

          throw new TypeError('val must be string, number or Buffer')
        }

        function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
          var indexSize = 1
          var arrLength = arr.length
          var valLength = val.length

          if (encoding !== undefined) {
            encoding = String(encoding).toLowerCase()
            if (encoding === 'ucs2' || encoding === 'ucs-2' ||
              encoding === 'utf16le' || encoding === 'utf-16le') {
              if (arr.length < 2 || val.length < 2) {
                return -1
              }
              indexSize = 2
              arrLength /= 2
              valLength /= 2
              byteOffset /= 2
            }
          }

          function read(buf, i) {
            if (indexSize === 1) {
              return buf[i]
            } else {
              return buf.readUInt16BE(i * indexSize)
            }
          }

          var i
          if (dir) {
            var foundIndex = -1
            for (i = byteOffset; i < arrLength; i++) {
              if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
                if (foundIndex === -1) foundIndex = i
                if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
              } else {
                if (foundIndex !== -1) i -= i - foundIndex
                foundIndex = -1
              }
            }
          } else {
            if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
            for (i = byteOffset; i >= 0; i--) {
              var found = true
              for (var j = 0; j < valLength; j++) {
                if (read(arr, i + j) !== read(val, j)) {
                  found = false
                  break
                }
              }
              if (found) return i
            }
          }

          return -1
        }

        Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
          return this.indexOf(val, byteOffset, encoding) !== -1
        }

        Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
          return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
        }

        Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
          return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
        }

        function hexWrite(buf, string, offset, length) {
          offset = Number(offset) || 0
          var remaining = buf.length - offset
          if (!length) {
            length = remaining
          } else {
            length = Number(length)
            if (length > remaining) {
              length = remaining
            }
          }

          var strLen = string.length

          if (length > strLen / 2) {
            length = strLen / 2
          }
          for (var i = 0; i < length; ++i) {
            var parsed = parseInt(string.substr(i * 2, 2), 16)
            if (numberIsNaN(parsed)) return i
            buf[offset + i] = parsed
          }
          return i
        }

        function utf8Write(buf, string, offset, length) {
          return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
        }

        function asciiWrite(buf, string, offset, length) {
          return blitBuffer(asciiToBytes(string), buf, offset, length)
        }

        function latin1Write(buf, string, offset, length) {
          return asciiWrite(buf, string, offset, length)
        }

        function base64Write(buf, string, offset, length) {
          return blitBuffer(base64ToBytes(string), buf, offset, length)
        }

        function ucs2Write(buf, string, offset, length) {
          return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
        }

        Buffer.prototype.write = function write(string, offset, length, encoding) {
          // Buffer#write(string)
          if (offset === undefined) {
            encoding = 'utf8'
            length = this.length
            offset = 0
            // Buffer#write(string, encoding)
          } else if (length === undefined && typeof offset === 'string') {
            encoding = offset
            length = this.length
            offset = 0
            // Buffer#write(string, offset[, length][, encoding])
          } else if (isFinite(offset)) {
            offset = offset >>> 0
            if (isFinite(length)) {
              length = length >>> 0
              if (encoding === undefined) encoding = 'utf8'
            } else {
              encoding = length
              length = undefined
            }
          } else {
            throw new Error(
              'Buffer.write(string, encoding, offset[, length]) is no longer supported'
            )
          }

          var remaining = this.length - offset
          if (length === undefined || length > remaining) length = remaining

          if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
            throw new RangeError('Attempt to write outside buffer bounds')
          }

          if (!encoding) encoding = 'utf8'

          var loweredCase = false
          for (; ;) {
            switch (encoding) {
              case 'hex':
                return hexWrite(this, string, offset, length)

              case 'utf8':
              case 'utf-8':
                return utf8Write(this, string, offset, length)

              case 'ascii':
                return asciiWrite(this, string, offset, length)

              case 'latin1':
              case 'binary':
                return latin1Write(this, string, offset, length)

              case 'base64':
                // Warning: maxLength not taken into account in base64Write
                return base64Write(this, string, offset, length)

              case 'ucs2':
              case 'ucs-2':
              case 'utf16le':
              case 'utf-16le':
                return ucs2Write(this, string, offset, length)

              default:
                if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                encoding = ('' + encoding).toLowerCase()
                loweredCase = true
            }
          }
        }

        Buffer.prototype.toJSON = function toJSON() {
          return {
            type: 'Buffer',
            data: Array.prototype.slice.call(this._arr || this, 0)
          }
        }

        function base64Slice(buf, start, end) {
          if (start === 0 && end === buf.length) {
            return base64.fromByteArray(buf)
          } else {
            return base64.fromByteArray(buf.slice(start, end))
          }
        }

        function utf8Slice(buf, start, end) {
          end = Math.min(buf.length, end)
          var res = []

          var i = start
          while (i < end) {
            var firstByte = buf[i]
            var codePoint = null
            var bytesPerSequence = (firstByte > 0xEF) ? 4
              : (firstByte > 0xDF) ? 3
                : (firstByte > 0xBF) ? 2
                  : 1

            if (i + bytesPerSequence <= end) {
              var secondByte, thirdByte, fourthByte, tempCodePoint

              switch (bytesPerSequence) {
                case 1:
                  if (firstByte < 0x80) {
                    codePoint = firstByte
                  }
                  break
                case 2:
                  secondByte = buf[i + 1]
                  if ((secondByte & 0xC0) === 0x80) {
                    tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
                    if (tempCodePoint > 0x7F) {
                      codePoint = tempCodePoint
                    }
                  }
                  break
                case 3:
                  secondByte = buf[i + 1]
                  thirdByte = buf[i + 2]
                  if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
                    tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
                    if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                      codePoint = tempCodePoint
                    }
                  }
                  break
                case 4:
                  secondByte = buf[i + 1]
                  thirdByte = buf[i + 2]
                  fourthByte = buf[i + 3]
                  if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
                    tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
                    if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                      codePoint = tempCodePoint
                    }
                  }
              }
            }

            if (codePoint === null) {
              // we did not generate a valid codePoint so insert a
              // replacement char (U+FFFD) and advance only 1 byte
              codePoint = 0xFFFD
              bytesPerSequence = 1
            } else if (codePoint > 0xFFFF) {
              // encode to utf16 (surrogate pair dance)
              codePoint -= 0x10000
              res.push(codePoint >>> 10 & 0x3FF | 0xD800)
              codePoint = 0xDC00 | codePoint & 0x3FF
            }

            res.push(codePoint)
            i += bytesPerSequence
          }

          return decodeCodePointsArray(res)
        }

        // Based on http://stackoverflow.com/a/22747272/680742, the browser with
        // the lowest limit is Chrome, with 0x10000 args.
        // We go 1 magnitude less, for safety
        var MAX_ARGUMENTS_LENGTH = 0x1000

        function decodeCodePointsArray(codePoints) {
          var len = codePoints.length
          if (len <= MAX_ARGUMENTS_LENGTH) {
            return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
          }

          // Decode in chunks to avoid "call stack size exceeded".
          var res = ''
          var i = 0
          while (i < len) {
            res += String.fromCharCode.apply(
              String,
              codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
            )
          }
          return res
        }

        function asciiSlice(buf, start, end) {
          var ret = ''
          end = Math.min(buf.length, end)

          for (var i = start; i < end; ++i) {
            ret += String.fromCharCode(buf[i] & 0x7F)
          }
          return ret
        }

        function latin1Slice(buf, start, end) {
          var ret = ''
          end = Math.min(buf.length, end)

          for (var i = start; i < end; ++i) {
            ret += String.fromCharCode(buf[i])
          }
          return ret
        }

        function hexSlice(buf, start, end) {
          var len = buf.length

          if (!start || start < 0) start = 0
          if (!end || end < 0 || end > len) end = len

          var out = ''
          for (var i = start; i < end; ++i) {
            out += toHex(buf[i])
          }
          return out
        }

        function utf16leSlice(buf, start, end) {
          var bytes = buf.slice(start, end)
          var res = ''
          for (var i = 0; i < bytes.length; i += 2) {
            res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
          }
          return res
        }

        Buffer.prototype.slice = function slice(start, end) {
          var len = this.length
          start = ~~start
          end = end === undefined ? len : ~~end

          if (start < 0) {
            start += len
            if (start < 0) start = 0
          } else if (start > len) {
            start = len
          }

          if (end < 0) {
            end += len
            if (end < 0) end = 0
          } else if (end > len) {
            end = len
          }

          if (end < start) end = start

          var newBuf = this.subarray(start, end)
          // Return an augmented `Uint8Array` instance
          newBuf.__proto__ = Buffer.prototype
          return newBuf
        }

        /*
         * Need to make sure that buffer isn't trying to write out of bounds.
         */
        function checkOffset(offset, ext, length) {
          if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
          if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
        }

        Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
          offset = offset >>> 0
          byteLength = byteLength >>> 0
          if (!noAssert) checkOffset(offset, byteLength, this.length)

          var val = this[offset]
          var mul = 1
          var i = 0
          while (++i < byteLength && (mul *= 0x100)) {
            val += this[offset + i] * mul
          }

          return val
        }

        Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
          offset = offset >>> 0
          byteLength = byteLength >>> 0
          if (!noAssert) {
            checkOffset(offset, byteLength, this.length)
          }

          var val = this[offset + --byteLength]
          var mul = 1
          while (byteLength > 0 && (mul *= 0x100)) {
            val += this[offset + --byteLength] * mul
          }

          return val
        }

        Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 1, this.length)
          return this[offset]
        }

        Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 2, this.length)
          return this[offset] | (this[offset + 1] << 8)
        }

        Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 2, this.length)
          return (this[offset] << 8) | this[offset + 1]
        }

        Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 4, this.length)

          return ((this[offset]) |
            (this[offset + 1] << 8) |
            (this[offset + 2] << 16)) +
            (this[offset + 3] * 0x1000000)
        }

        Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 4, this.length)

          return (this[offset] * 0x1000000) +
            ((this[offset + 1] << 16) |
              (this[offset + 2] << 8) |
              this[offset + 3])
        }

        Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
          offset = offset >>> 0
          byteLength = byteLength >>> 0
          if (!noAssert) checkOffset(offset, byteLength, this.length)

          var val = this[offset]
          var mul = 1
          var i = 0
          while (++i < byteLength && (mul *= 0x100)) {
            val += this[offset + i] * mul
          }
          mul *= 0x80

          if (val >= mul) val -= Math.pow(2, 8 * byteLength)

          return val
        }

        Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
          offset = offset >>> 0
          byteLength = byteLength >>> 0
          if (!noAssert) checkOffset(offset, byteLength, this.length)

          var i = byteLength
          var mul = 1
          var val = this[offset + --i]
          while (i > 0 && (mul *= 0x100)) {
            val += this[offset + --i] * mul
          }
          mul *= 0x80

          if (val >= mul) val -= Math.pow(2, 8 * byteLength)

          return val
        }

        Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 1, this.length)
          if (!(this[offset] & 0x80)) return (this[offset])
          return ((0xff - this[offset] + 1) * -1)
        }

        Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 2, this.length)
          var val = this[offset] | (this[offset + 1] << 8)
          return (val & 0x8000) ? val | 0xFFFF0000 : val
        }

        Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 2, this.length)
          var val = this[offset + 1] | (this[offset] << 8)
          return (val & 0x8000) ? val | 0xFFFF0000 : val
        }

        Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 4, this.length)

          return (this[offset]) |
            (this[offset + 1] << 8) |
            (this[offset + 2] << 16) |
            (this[offset + 3] << 24)
        }

        Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 4, this.length)

          return (this[offset] << 24) |
            (this[offset + 1] << 16) |
            (this[offset + 2] << 8) |
            (this[offset + 3])
        }

        Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 4, this.length)
          return ieee754.read(this, offset, true, 23, 4)
        }

        Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 4, this.length)
          return ieee754.read(this, offset, false, 23, 4)
        }

        Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 8, this.length)
          return ieee754.read(this, offset, true, 52, 8)
        }

        Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
          offset = offset >>> 0
          if (!noAssert) checkOffset(offset, 8, this.length)
          return ieee754.read(this, offset, false, 52, 8)
        }

        function checkInt(buf, value, offset, ext, max, min) {
          if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
          if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
          if (offset + ext > buf.length) throw new RangeError('Index out of range')
        }

        Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
          value = +value
          offset = offset >>> 0
          byteLength = byteLength >>> 0
          if (!noAssert) {
            var maxBytes = Math.pow(2, 8 * byteLength) - 1
            checkInt(this, value, offset, byteLength, maxBytes, 0)
          }

          var mul = 1
          var i = 0
          this[offset] = value & 0xFF
          while (++i < byteLength && (mul *= 0x100)) {
            this[offset + i] = (value / mul) & 0xFF
          }

          return offset + byteLength
        }

        Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
          value = +value
          offset = offset >>> 0
          byteLength = byteLength >>> 0
          if (!noAssert) {
            var maxBytes = Math.pow(2, 8 * byteLength) - 1
            checkInt(this, value, offset, byteLength, maxBytes, 0)
          }

          var i = byteLength - 1
          var mul = 1
          this[offset + i] = value & 0xFF
          while (--i >= 0 && (mul *= 0x100)) {
            this[offset + i] = (value / mul) & 0xFF
          }

          return offset + byteLength
        }

        Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
          this[offset] = (value & 0xff)
          return offset + 1
        }

        Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
          this[offset] = (value & 0xff)
          this[offset + 1] = (value >>> 8)
          return offset + 2
        }

        Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
          this[offset] = (value >>> 8)
          this[offset + 1] = (value & 0xff)
          return offset + 2
        }

        Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
          this[offset + 3] = (value >>> 24)
          this[offset + 2] = (value >>> 16)
          this[offset + 1] = (value >>> 8)
          this[offset] = (value & 0xff)
          return offset + 4
        }

        Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
          this[offset] = (value >>> 24)
          this[offset + 1] = (value >>> 16)
          this[offset + 2] = (value >>> 8)
          this[offset + 3] = (value & 0xff)
          return offset + 4
        }

        Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) {
            var limit = Math.pow(2, (8 * byteLength) - 1)

            checkInt(this, value, offset, byteLength, limit - 1, -limit)
          }

          var i = 0
          var mul = 1
          var sub = 0
          this[offset] = value & 0xFF
          while (++i < byteLength && (mul *= 0x100)) {
            if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
              sub = 1
            }
            this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
          }

          return offset + byteLength
        }

        Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) {
            var limit = Math.pow(2, (8 * byteLength) - 1)

            checkInt(this, value, offset, byteLength, limit - 1, -limit)
          }

          var i = byteLength - 1
          var mul = 1
          var sub = 0
          this[offset + i] = value & 0xFF
          while (--i >= 0 && (mul *= 0x100)) {
            if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
              sub = 1
            }
            this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
          }

          return offset + byteLength
        }

        Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
          if (value < 0) value = 0xff + value + 1
          this[offset] = (value & 0xff)
          return offset + 1
        }

        Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
          this[offset] = (value & 0xff)
          this[offset + 1] = (value >>> 8)
          return offset + 2
        }

        Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
          this[offset] = (value >>> 8)
          this[offset + 1] = (value & 0xff)
          return offset + 2
        }

        Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
          this[offset] = (value & 0xff)
          this[offset + 1] = (value >>> 8)
          this[offset + 2] = (value >>> 16)
          this[offset + 3] = (value >>> 24)
          return offset + 4
        }

        Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
          if (value < 0) value = 0xffffffff + value + 1
          this[offset] = (value >>> 24)
          this[offset + 1] = (value >>> 16)
          this[offset + 2] = (value >>> 8)
          this[offset + 3] = (value & 0xff)
          return offset + 4
        }

        function checkIEEE754(buf, value, offset, ext, max, min) {
          if (offset + ext > buf.length) throw new RangeError('Index out of range')
          if (offset < 0) throw new RangeError('Index out of range')
        }

        function writeFloat(buf, value, offset, littleEndian, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) {
            checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
          }
          ieee754.write(buf, value, offset, littleEndian, 23, 4)
          return offset + 4
        }

        Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
          return writeFloat(this, value, offset, true, noAssert)
        }

        Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
          return writeFloat(this, value, offset, false, noAssert)
        }

        function writeDouble(buf, value, offset, littleEndian, noAssert) {
          value = +value
          offset = offset >>> 0
          if (!noAssert) {
            checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
          }
          ieee754.write(buf, value, offset, littleEndian, 52, 8)
          return offset + 8
        }

        Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
          return writeDouble(this, value, offset, true, noAssert)
        }

        Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
          return writeDouble(this, value, offset, false, noAssert)
        }

        // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
        Buffer.prototype.copy = function copy(target, targetStart, start, end) {
          if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
          if (!start) start = 0
          if (!end && end !== 0) end = this.length
          if (targetStart >= target.length) targetStart = target.length
          if (!targetStart) targetStart = 0
          if (end > 0 && end < start) end = start

          // Copy 0 bytes; we're done
          if (end === start) return 0
          if (target.length === 0 || this.length === 0) return 0

          // Fatal error conditions
          if (targetStart < 0) {
            throw new RangeError('targetStart out of bounds')
          }
          if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
          if (end < 0) throw new RangeError('sourceEnd out of bounds')

          // Are we oob?
          if (end > this.length) end = this.length
          if (target.length - targetStart < end - start) {
            end = target.length - targetStart + start
          }

          var len = end - start

          if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
            // Use built-in when available, missing from IE11
            this.copyWithin(targetStart, start, end)
          } else if (this === target && start < targetStart && targetStart < end) {
            // descending copy from end
            for (var i = len - 1; i >= 0; --i) {
              target[i + targetStart] = this[i + start]
            }
          } else {
            Uint8Array.prototype.set.call(
              target,
              this.subarray(start, end),
              targetStart
            )
          }

          return len
        }

        // Usage:
        //    buffer.fill(number[, offset[, end]])
        //    buffer.fill(buffer[, offset[, end]])
        //    buffer.fill(string[, offset[, end]][, encoding])
        Buffer.prototype.fill = function fill(val, start, end, encoding) {
          // Handle string cases:
          if (typeof val === 'string') {
            if (typeof start === 'string') {
              encoding = start
              start = 0
              end = this.length
            } else if (typeof end === 'string') {
              encoding = end
              end = this.length
            }
            if (encoding !== undefined && typeof encoding !== 'string') {
              throw new TypeError('encoding must be a string')
            }
            if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
              throw new TypeError('Unknown encoding: ' + encoding)
            }
            if (val.length === 1) {
              var code = val.charCodeAt(0)
              if ((encoding === 'utf8' && code < 128) ||
                encoding === 'latin1') {
                // Fast path: If `val` fits into a single byte, use that numeric value.
                val = code
              }
            }
          } else if (typeof val === 'number') {
            val = val & 255
          }

          // Invalid ranges are not set to a default, so can range check early.
          if (start < 0 || this.length < start || this.length < end) {
            throw new RangeError('Out of range index')
          }

          if (end <= start) {
            return this
          }

          start = start >>> 0
          end = end === undefined ? this.length : end >>> 0

          if (!val) val = 0

          var i
          if (typeof val === 'number') {
            for (i = start; i < end; ++i) {
              this[i] = val
            }
          } else {
            var bytes = Buffer.isBuffer(val)
              ? val
              : Buffer.from(val, encoding)
            var len = bytes.length
            if (len === 0) {
              throw new TypeError('The value "' + val +
                '" is invalid for argument "value"')
            }
            for (i = 0; i < end - start; ++i) {
              this[i + start] = bytes[i % len]
            }
          }

          return this
        }

        // HELPER FUNCTIONS
        // ================

        var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g

        function base64clean(str) {
          // Node takes equal signs as end of the Base64 encoding
          str = str.split('=')[0]
          // Node strips out invalid characters like \n and \t from the string, base64-js does not
          str = str.trim().replace(INVALID_BASE64_RE, '')
          // Node converts strings with length < 2 to ''
          if (str.length < 2) return ''
          // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
          while (str.length % 4 !== 0) {
            str = str + '='
          }
          return str
        }

        function toHex(n) {
          if (n < 16) return '0' + n.toString(16)
          return n.toString(16)
        }

        function utf8ToBytes(string, units) {
          units = units || Infinity
          var codePoint
          var length = string.length
          var leadSurrogate = null
          var bytes = []

          for (var i = 0; i < length; ++i) {
            codePoint = string.charCodeAt(i)

            // is surrogate component
            if (codePoint > 0xD7FF && codePoint < 0xE000) {
              // last char was a lead
              if (!leadSurrogate) {
                // no lead yet
                if (codePoint > 0xDBFF) {
                  // unexpected trail
                  if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                  continue
                } else if (i + 1 === length) {
                  // unpaired lead
                  if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                  continue
                }

                // valid lead
                leadSurrogate = codePoint

                continue
              }

              // 2 leads in a row
              if (codePoint < 0xDC00) {
                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                leadSurrogate = codePoint
                continue
              }

              // valid surrogate pair
              codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
            } else if (leadSurrogate) {
              // valid bmp char, but last char was a lead
              if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
            }

            leadSurrogate = null

            // encode utf8
            if (codePoint < 0x80) {
              if ((units -= 1) < 0) break
              bytes.push(codePoint)
            } else if (codePoint < 0x800) {
              if ((units -= 2) < 0) break
              bytes.push(
                codePoint >> 0x6 | 0xC0,
                codePoint & 0x3F | 0x80
              )
            } else if (codePoint < 0x10000) {
              if ((units -= 3) < 0) break
              bytes.push(
                codePoint >> 0xC | 0xE0,
                codePoint >> 0x6 & 0x3F | 0x80,
                codePoint & 0x3F | 0x80
              )
            } else if (codePoint < 0x110000) {
              if ((units -= 4) < 0) break
              bytes.push(
                codePoint >> 0x12 | 0xF0,
                codePoint >> 0xC & 0x3F | 0x80,
                codePoint >> 0x6 & 0x3F | 0x80,
                codePoint & 0x3F | 0x80
              )
            } else {
              throw new Error('Invalid code point')
            }
          }

          return bytes
        }

        function asciiToBytes(str) {
          var byteArray = []
          for (var i = 0; i < str.length; ++i) {
            // Node's code seems to be doing this and not & 0x7F..
            byteArray.push(str.charCodeAt(i) & 0xFF)
          }
          return byteArray
        }

        function utf16leToBytes(str, units) {
          var c, hi, lo
          var byteArray = []
          for (var i = 0; i < str.length; ++i) {
            if ((units -= 2) < 0) break

            c = str.charCodeAt(i)
            hi = c >> 8
            lo = c % 256
            byteArray.push(lo)
            byteArray.push(hi)
          }

          return byteArray
        }

        function base64ToBytes(str) {
          return base64.toByteArray(base64clean(str))
        }

        function blitBuffer(src, dst, offset, length) {
          for (var i = 0; i < length; ++i) {
            if ((i + offset >= dst.length) || (i >= src.length)) break
            dst[i + offset] = src[i]
          }
          return i
        }

        // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
        // the `instanceof` check but they should be treated as of that type.
        // See: https://github.com/feross/buffer/issues/166
        function isInstance(obj, type) {
          return obj instanceof type ||
            (obj != null && obj.constructor != null && obj.constructor.name != null &&
              obj.constructor.name === type.name)
        }
        function numberIsNaN(obj) {
          // For IE11 support
          return obj !== obj // eslint-disable-line no-self-compare
        }

      }).call(this, require("buffer").Buffer)
    }, { "base64-js": 10, "buffer": 12, "ieee754": 87 }], 13: [function (require, module, exports) {
      (function (Buffer) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        // NOTE: These type checking functions intentionally don't use `instanceof`
        // because it is fragile and can be easily faked with `Object.create()`.

        function isArray(arg) {
          if (Array.isArray) {
            return Array.isArray(arg);
          }
          return objectToString(arg) === '[object Array]';
        }
        exports.isArray = isArray;

        function isBoolean(arg) {
          return typeof arg === 'boolean';
        }
        exports.isBoolean = isBoolean;

        function isNull(arg) {
          return arg === null;
        }
        exports.isNull = isNull;

        function isNullOrUndefined(arg) {
          return arg == null;
        }
        exports.isNullOrUndefined = isNullOrUndefined;

        function isNumber(arg) {
          return typeof arg === 'number';
        }
        exports.isNumber = isNumber;

        function isString(arg) {
          return typeof arg === 'string';
        }
        exports.isString = isString;

        function isSymbol(arg) {
          return typeof arg === 'symbol';
        }
        exports.isSymbol = isSymbol;

        function isUndefined(arg) {
          return arg === void 0;
        }
        exports.isUndefined = isUndefined;

        function isRegExp(re) {
          return objectToString(re) === '[object RegExp]';
        }
        exports.isRegExp = isRegExp;

        function isObject(arg) {
          return typeof arg === 'object' && arg !== null;
        }
        exports.isObject = isObject;

        function isDate(d) {
          return objectToString(d) === '[object Date]';
        }
        exports.isDate = isDate;

        function isError(e) {
          return (objectToString(e) === '[object Error]' || e instanceof Error);
        }
        exports.isError = isError;

        function isFunction(arg) {
          return typeof arg === 'function';
        }
        exports.isFunction = isFunction;

        function isPrimitive(arg) {
          return arg === null ||
            typeof arg === 'boolean' ||
            typeof arg === 'number' ||
            typeof arg === 'string' ||
            typeof arg === 'symbol' ||  // ES6 symbol
            typeof arg === 'undefined';
        }
        exports.isPrimitive = isPrimitive;

        exports.isBuffer = Buffer.isBuffer;

        function objectToString(o) {
          return Object.prototype.toString.call(o);
        }

      }).call(this, { "isBuffer": require("../../is-buffer/index.js") })
    }, { "../../is-buffer/index.js": 89 }], 14: [function (require, module, exports) {
      "use strict";

      var isValue = require("type/value/is")
        , ensureValue = require("type/value/ensure")
        , ensurePlainFunction = require("type/plain-function/ensure")
        , copy = require("es5-ext/object/copy")
        , normalizeOptions = require("es5-ext/object/normalize-options")
        , map = require("es5-ext/object/map");

      var bind = Function.prototype.bind
        , defineProperty = Object.defineProperty
        , hasOwnProperty = Object.prototype.hasOwnProperty
        , define;

      define = function (name, desc, options) {
        var value = ensureValue(desc) && ensurePlainFunction(desc.value), dgs;
        dgs = copy(desc);
        delete dgs.writable;
        delete dgs.value;
        dgs.get = function () {
          if (!options.overwriteDefinition && hasOwnProperty.call(this, name)) return value;
          desc.value = bind.call(value, options.resolveContext ? options.resolveContext(this) : this);
          defineProperty(this, name, desc);
          return this[name];
        };
        return dgs;
      };

      module.exports = function (props/*, options*/) {
        var options = normalizeOptions(arguments[1]);
        if (isValue(options.resolveContext)) ensurePlainFunction(options.resolveContext);
        return map(props, function (desc, name) { return define(name, desc, options); });
      };

    }, { "es5-ext/object/copy": 41, "es5-ext/object/map": 49, "es5-ext/object/normalize-options": 50, "type/plain-function/ensure": 126, "type/value/ensure": 130, "type/value/is": 131 }], 15: [function (require, module, exports) {
      "use strict";

      var isValue = require("type/value/is")
        , isPlainFunction = require("type/plain-function/is")
        , assign = require("es5-ext/object/assign")
        , normalizeOpts = require("es5-ext/object/normalize-options")
        , contains = require("es5-ext/string/#/contains");

      var d = (module.exports = function (dscr, value/*, options*/) {
        var c, e, w, options, desc;
        if (arguments.length < 2 || typeof dscr !== "string") {
          options = value;
          value = dscr;
          dscr = null;
        } else {
          options = arguments[2];
        }
        if (isValue(dscr)) {
          c = contains.call(dscr, "c");
          e = contains.call(dscr, "e");
          w = contains.call(dscr, "w");
        } else {
          c = w = true;
          e = false;
        }

        desc = { value: value, configurable: c, enumerable: e, writable: w };
        return !options ? desc : assign(normalizeOpts(options), desc);
      });

      d.gs = function (dscr, get, set/*, options*/) {
        var c, e, options, desc;
        if (typeof dscr !== "string") {
          options = set;
          set = get;
          get = dscr;
          dscr = null;
        } else {
          options = arguments[3];
        }
        if (!isValue(get)) {
          get = undefined;
        } else if (!isPlainFunction(get)) {
          options = get;
          get = set = undefined;
        } else if (!isValue(set)) {
          set = undefined;
        } else if (!isPlainFunction(set)) {
          options = set;
          set = undefined;
        }
        if (isValue(dscr)) {
          c = contains.call(dscr, "c");
          e = contains.call(dscr, "e");
        } else {
          c = true;
          e = false;
        }

        desc = { get: get, set: set, configurable: c, enumerable: e };
        return !options ? desc : assign(normalizeOpts(options), desc);
      };

    }, { "es5-ext/object/assign": 38, "es5-ext/object/normalize-options": 50, "es5-ext/string/#/contains": 57, "type/plain-function/is": 127, "type/value/is": 131 }], 16: [function (require, module, exports) {
      /**
       * Helpers.
       */

      var s = 1000;
      var m = s * 60;
      var h = m * 60;
      var d = h * 24;
      var w = d * 7;
      var y = d * 365.25;

      /**
       * Parse or format the given `val`.
       *
       * Options:
       *
       *  - `long` verbose formatting [false]
       *
       * @param {String|Number} val
       * @param {Object} [options]
       * @throws {Error} throw an error if val is not a non-empty string or a number
       * @return {String|Number}
       * @api public
       */

      module.exports = function (val, options) {
        options = options || {};
        var type = typeof val;
        if (type === 'string' && val.length > 0) {
          return parse(val);
        } else if (type === 'number' && isFinite(val)) {
          return options.long ? fmtLong(val) : fmtShort(val);
        }
        throw new Error(
          'val is not a non-empty string or a valid number. val=' +
          JSON.stringify(val)
        );
      };

      /**
       * Parse the given `str` and return milliseconds.
       *
       * @param {String} str
       * @return {Number}
       * @api private
       */

      function parse(str) {
        str = String(str);
        if (str.length > 100) {
          return;
        }
        var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
          str
        );
        if (!match) {
          return;
        }
        var n = parseFloat(match[1]);
        var type = (match[2] || 'ms').toLowerCase();
        switch (type) {
          case 'years':
          case 'year':
          case 'yrs':
          case 'yr':
          case 'y':
            return n * y;
          case 'weeks':
          case 'week':
          case 'w':
            return n * w;
          case 'days':
          case 'day':
          case 'd':
            return n * d;
          case 'hours':
          case 'hour':
          case 'hrs':
          case 'hr':
          case 'h':
            return n * h;
          case 'minutes':
          case 'minute':
          case 'mins':
          case 'min':
          case 'm':
            return n * m;
          case 'seconds':
          case 'second':
          case 'secs':
          case 'sec':
          case 's':
            return n * s;
          case 'milliseconds':
          case 'millisecond':
          case 'msecs':
          case 'msec':
          case 'ms':
            return n;
          default:
            return undefined;
        }
      }

      /**
       * Short format for `ms`.
       *
       * @param {Number} ms
       * @return {String}
       * @api private
       */

      function fmtShort(ms) {
        var msAbs = Math.abs(ms);
        if (msAbs >= d) {
          return Math.round(ms / d) + 'd';
        }
        if (msAbs >= h) {
          return Math.round(ms / h) + 'h';
        }
        if (msAbs >= m) {
          return Math.round(ms / m) + 'm';
        }
        if (msAbs >= s) {
          return Math.round(ms / s) + 's';
        }
        return ms + 'ms';
      }

      /**
       * Long format for `ms`.
       *
       * @param {Number} ms
       * @return {String}
       * @api private
       */

      function fmtLong(ms) {
        var msAbs = Math.abs(ms);
        if (msAbs >= d) {
          return plural(ms, msAbs, d, 'day');
        }
        if (msAbs >= h) {
          return plural(ms, msAbs, h, 'hour');
        }
        if (msAbs >= m) {
          return plural(ms, msAbs, m, 'minute');
        }
        if (msAbs >= s) {
          return plural(ms, msAbs, s, 'second');
        }
        return ms + ' ms';
      }

      /**
       * Pluralization helper.
       */

      function plural(ms, msAbs, n, name) {
        var isPlural = msAbs >= n * 1.5;
        return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
      }

    }, {}], 17: [function (require, module, exports) {
      (function (process) {
        /* eslint-env browser */

        /**
         * This is the web browser implementation of `debug()`.
         */

        exports.log = log;
        exports.formatArgs = formatArgs;
        exports.save = save;
        exports.load = load;
        exports.useColors = useColors;
        exports.storage = localstorage();

        /**
         * Colors.
         */

        exports.colors = [
          '#0000CC',
          '#0000FF',
          '#0033CC',
          '#0033FF',
          '#0066CC',
          '#0066FF',
          '#0099CC',
          '#0099FF',
          '#00CC00',
          '#00CC33',
          '#00CC66',
          '#00CC99',
          '#00CCCC',
          '#00CCFF',
          '#3300CC',
          '#3300FF',
          '#3333CC',
          '#3333FF',
          '#3366CC',
          '#3366FF',
          '#3399CC',
          '#3399FF',
          '#33CC00',
          '#33CC33',
          '#33CC66',
          '#33CC99',
          '#33CCCC',
          '#33CCFF',
          '#6600CC',
          '#6600FF',
          '#6633CC',
          '#6633FF',
          '#66CC00',
          '#66CC33',
          '#9900CC',
          '#9900FF',
          '#9933CC',
          '#9933FF',
          '#99CC00',
          '#99CC33',
          '#CC0000',
          '#CC0033',
          '#CC0066',
          '#CC0099',
          '#CC00CC',
          '#CC00FF',
          '#CC3300',
          '#CC3333',
          '#CC3366',
          '#CC3399',
          '#CC33CC',
          '#CC33FF',
          '#CC6600',
          '#CC6633',
          '#CC9900',
          '#CC9933',
          '#CCCC00',
          '#CCCC33',
          '#FF0000',
          '#FF0033',
          '#FF0066',
          '#FF0099',
          '#FF00CC',
          '#FF00FF',
          '#FF3300',
          '#FF3333',
          '#FF3366',
          '#FF3399',
          '#FF33CC',
          '#FF33FF',
          '#FF6600',
          '#FF6633',
          '#FF9900',
          '#FF9933',
          '#FFCC00',
          '#FFCC33'
        ];

        /**
         * Currently only WebKit-based Web Inspectors, Firefox >= v31,
         * and the Firebug extension (any Firefox version) are known
         * to support "%c" CSS customizations.
         *
         * TODO: add a `localStorage` variable to explicitly enable/disable colors
         */

        // eslint-disable-next-line complexity
        function useColors() {
          // NB: In an Electron preload script, document will be defined but not fully
          // initialized. Since we know we're in Chrome, we'll just detect this case
          // explicitly
          if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
            return true;
          }

          // Internet Explorer and Edge do not support colors.
          if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
            return false;
          }

          // Is webkit? http://stackoverflow.com/a/16459606/376773
          // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
          return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
            // Is firebug? http://stackoverflow.com/a/398120/376773
            (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
            // Is firefox >= v31?
            // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
            (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
            // Double check webkit in userAgent just in case we are in a worker
            (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
        }

        /**
         * Colorize log arguments if enabled.
         *
         * @api public
         */

        function formatArgs(args) {
          args[0] = (this.useColors ? '%c' : '') +
            this.namespace +
            (this.useColors ? ' %c' : ' ') +
            args[0] +
            (this.useColors ? '%c ' : ' ') +
            '+' + module.exports.humanize(this.diff);

          if (!this.useColors) {
            return;
          }

          const c = 'color: ' + this.color;
          args.splice(1, 0, c, 'color: inherit');

          // The final "%c" is somewhat tricky, because there could be other
          // arguments passed either before or after the %c, so we need to
          // figure out the correct index to insert the CSS into
          let index = 0;
          let lastC = 0;
          args[0].replace(/%[a-zA-Z%]/g, match => {
            if (match === '%%') {
              return;
            }
            index++;
            if (match === '%c') {
              // We only are interested in the *last* %c
              // (the user may have provided their own)
              lastC = index;
            }
          });

          args.splice(lastC, 0, c);
        }

        /**
         * Invokes `console.log()` when available.
         * No-op when `console.log` is not a "function".
         *
         * @api public
         */
        function log(...args) {
          // This hackery is required for IE8/9, where
          // the `console.log` function doesn't have 'apply'
          return typeof console === 'object' &&
            console.log &&
            console.log(...args);
        }

        /**
         * Save `namespaces`.
         *
         * @param {String} namespaces
         * @api private
         */
        function save(namespaces) {
          try {
            if (namespaces) {
              exports.storage.setItem('debug', namespaces);
            } else {
              exports.storage.removeItem('debug');
            }
          } catch (error) {
            // Swallow
            // XXX (@Qix-) should we be logging these?
          }
        }

        /**
         * Load `namespaces`.
         *
         * @return {String} returns the previously persisted debug modes
         * @api private
         */
        function load() {
          let r;
          try {
            r = exports.storage.getItem('debug');
          } catch (error) {
            // Swallow
            // XXX (@Qix-) should we be logging these?
          }

          // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
          if (!r && typeof process !== 'undefined' && 'env' in process) {
            r = process.env.DEBUG;
          }

          return r;
        }

        /**
         * Localstorage attempts to return the localstorage.
         *
         * This is necessary because safari throws
         * when a user disables cookies/localstorage
         * and you attempt to access it.
         *
         * @return {LocalStorage}
         * @api private
         */

        function localstorage() {
          try {
            // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
            // The Browser also has localStorage in the global context.
            return localStorage;
          } catch (error) {
            // Swallow
            // XXX (@Qix-) should we be logging these?
          }
        }

        module.exports = require('./common')(exports);

        const { formatters } = module.exports;

        /**
         * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
         */

        formatters.j = function (v) {
          try {
            return JSON.stringify(v);
          } catch (error) {
            return '[UnexpectedJSONParseError]: ' + error.message;
          }
        };

      }).call(this, require('_process'))
    }, { "./common": 18, "_process": 100 }], 18: [function (require, module, exports) {

      /**
       * This is the common logic for both the Node.js and web browser
       * implementations of `debug()`.
       */

      function setup(env) {
        createDebug.debug = createDebug;
        createDebug.default = createDebug;
        createDebug.coerce = coerce;
        createDebug.disable = disable;
        createDebug.enable = enable;
        createDebug.enabled = enabled;
        createDebug.humanize = require('ms');

        Object.keys(env).forEach(key => {
          createDebug[key] = env[key];
        });

        /**
        * Active `debug` instances.
        */
        createDebug.instances = [];

        /**
        * The currently active debug mode names, and names to skip.
        */

        createDebug.names = [];
        createDebug.skips = [];

        /**
        * Map of special "%n" handling functions, for the debug "format" argument.
        *
        * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
        */
        createDebug.formatters = {};

        /**
        * Selects a color for a debug namespace
        * @param {String} namespace The namespace string for the for the debug instance to be colored
        * @return {Number|String} An ANSI color code for the given namespace
        * @api private
        */
        function selectColor(namespace) {
          let hash = 0;

          for (let i = 0; i < namespace.length; i++) {
            hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
            hash |= 0; // Convert to 32bit integer
          }

          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
        }
        createDebug.selectColor = selectColor;

        /**
        * Create a debugger with the given `namespace`.
        *
        * @param {String} namespace
        * @return {Function}
        * @api public
        */
        function createDebug(namespace) {
          let prevTime;

          function debug(...args) {
            // Disabled?
            if (!debug.enabled) {
              return;
            }

            const self = debug;

            // Set `diff` timestamp
            const curr = Number(new Date());
            const ms = curr - (prevTime || curr);
            self.diff = ms;
            self.prev = prevTime;
            self.curr = curr;
            prevTime = curr;

            args[0] = createDebug.coerce(args[0]);

            if (typeof args[0] !== 'string') {
              // Anything else let's inspect with %O
              args.unshift('%O');
            }

            // Apply any `formatters` transformations
            let index = 0;
            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
              // If we encounter an escaped % then don't increase the array index
              if (match === '%%') {
                return match;
              }
              index++;
              const formatter = createDebug.formatters[format];
              if (typeof formatter === 'function') {
                const val = args[index];
                match = formatter.call(self, val);

                // Now we need to remove `args[index]` since it's inlined in the `format`
                args.splice(index, 1);
                index--;
              }
              return match;
            });

            // Apply env-specific formatting (colors, etc.)
            createDebug.formatArgs.call(self, args);

            const logFn = self.log || createDebug.log;
            logFn.apply(self, args);
          }

          debug.namespace = namespace;
          debug.enabled = createDebug.enabled(namespace);
          debug.useColors = createDebug.useColors();
          debug.color = selectColor(namespace);
          debug.destroy = destroy;
          debug.extend = extend;
          // Debug.formatArgs = formatArgs;
          // debug.rawLog = rawLog;

          // env-specific initialization logic for debug instances
          if (typeof createDebug.init === 'function') {
            createDebug.init(debug);
          }

          createDebug.instances.push(debug);

          return debug;
        }

        function destroy() {
          const index = createDebug.instances.indexOf(this);
          if (index !== -1) {
            createDebug.instances.splice(index, 1);
            return true;
          }
          return false;
        }

        function extend(namespace, delimiter) {
          const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
          newDebug.log = this.log;
          return newDebug;
        }

        /**
        * Enables a debug mode by namespaces. This can include modes
        * separated by a colon and wildcards.
        *
        * @param {String} namespaces
        * @api public
        */
        function enable(namespaces) {
          createDebug.save(namespaces);

          createDebug.names = [];
          createDebug.skips = [];

          let i;
          const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
          const len = split.length;

          for (i = 0; i < len; i++) {
            if (!split[i]) {
              // ignore empty strings
              continue;
            }

            namespaces = split[i].replace(/\*/g, '.*?');

            if (namespaces[0] === '-') {
              createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
            } else {
              createDebug.names.push(new RegExp('^' + namespaces + '$'));
            }
          }

          for (i = 0; i < createDebug.instances.length; i++) {
            const instance = createDebug.instances[i];
            instance.enabled = createDebug.enabled(instance.namespace);
          }
        }

        /**
        * Disable debug output.
        *
        * @return {String} namespaces
        * @api public
        */
        function disable() {
          const namespaces = [
            ...createDebug.names.map(toNamespace),
            ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
          ].join(',');
          createDebug.enable('');
          return namespaces;
        }

        /**
        * Returns true if the given mode name is enabled, false otherwise.
        *
        * @param {String} name
        * @return {Boolean}
        * @api public
        */
        function enabled(name) {
          if (name[name.length - 1] === '*') {
            return true;
          }

          let i;
          let len;

          for (i = 0, len = createDebug.skips.length; i < len; i++) {
            if (createDebug.skips[i].test(name)) {
              return false;
            }
          }

          for (i = 0, len = createDebug.names.length; i < len; i++) {
            if (createDebug.names[i].test(name)) {
              return true;
            }
          }

          return false;
        }

        /**
        * Convert regexp to namespace
        *
        * @param {RegExp} regxep
        * @return {String} namespace
        * @api private
        */
        function toNamespace(regexp) {
          return regexp.toString()
            .substring(2, regexp.toString().length - 2)
            .replace(/\.\*\?$/, '*');
        }

        /**
        * Coerce `val`.
        *
        * @param {Mixed} val
        * @return {Mixed}
        * @api private
        */
        function coerce(val) {
          if (val instanceof Error) {
            return val.stack || val.message;
          }
          return val;
        }

        createDebug.enable(createDebug.load());

        return createDebug;
      }

      module.exports = setup;

    }, { "ms": 16 }], 19: [function (require, module, exports) {
      (function (process, Buffer) {
        var stream = require('readable-stream')
        var eos = require('end-of-stream')
        var inherits = require('inherits')
        var shift = require('stream-shift')

        var SIGNAL_FLUSH = (Buffer.from && Buffer.from !== Uint8Array.from)
          ? Buffer.from([0])
          : new Buffer([0])

        var onuncork = function (self, fn) {
          if (self._corked) self.once('uncork', fn)
          else fn()
        }

        var autoDestroy = function (self, err) {
          if (self._autoDestroy) self.destroy(err)
        }

        var destroyer = function (self, end) {
          return function (err) {
            if (err) autoDestroy(self, err.message === 'premature close' ? null : err)
            else if (end && !self._ended) self.end()
          }
        }

        var end = function (ws, fn) {
          if (!ws) return fn()
          if (ws._writableState && ws._writableState.finished) return fn()
          if (ws._writableState) return ws.end(fn)
          ws.end()
          fn()
        }

        var toStreams2 = function (rs) {
          return new (stream.Readable)({ objectMode: true, highWaterMark: 16 }).wrap(rs)
        }

        var Duplexify = function (writable, readable, opts) {
          if (!(this instanceof Duplexify)) return new Duplexify(writable, readable, opts)
          stream.Duplex.call(this, opts)

          this._writable = null
          this._readable = null
          this._readable2 = null

          this._autoDestroy = !opts || opts.autoDestroy !== false
          this._forwardDestroy = !opts || opts.destroy !== false
          this._forwardEnd = !opts || opts.end !== false
          this._corked = 1 // start corked
          this._ondrain = null
          this._drained = false
          this._forwarding = false
          this._unwrite = null
          this._unread = null
          this._ended = false

          this.destroyed = false

          if (writable) this.setWritable(writable)
          if (readable) this.setReadable(readable)
        }

        inherits(Duplexify, stream.Duplex)

        Duplexify.obj = function (writable, readable, opts) {
          if (!opts) opts = {}
          opts.objectMode = true
          opts.highWaterMark = 16
          return new Duplexify(writable, readable, opts)
        }

        Duplexify.prototype.cork = function () {
          if (++this._corked === 1) this.emit('cork')
        }

        Duplexify.prototype.uncork = function () {
          if (this._corked && --this._corked === 0) this.emit('uncork')
        }

        Duplexify.prototype.setWritable = function (writable) {
          if (this._unwrite) this._unwrite()

          if (this.destroyed) {
            if (writable && writable.destroy) writable.destroy()
            return
          }

          if (writable === null || writable === false) {
            this.end()
            return
          }

          var self = this
          var unend = eos(writable, { writable: true, readable: false }, destroyer(this, this._forwardEnd))

          var ondrain = function () {
            var ondrain = self._ondrain
            self._ondrain = null
            if (ondrain) ondrain()
          }

          var clear = function () {
            self._writable.removeListener('drain', ondrain)
            unend()
          }

          if (this._unwrite) process.nextTick(ondrain) // force a drain on stream reset to avoid livelocks

          this._writable = writable
          this._writable.on('drain', ondrain)
          this._unwrite = clear

          this.uncork() // always uncork setWritable
        }

        Duplexify.prototype.setReadable = function (readable) {
          if (this._unread) this._unread()

          if (this.destroyed) {
            if (readable && readable.destroy) readable.destroy()
            return
          }

          if (readable === null || readable === false) {
            this.push(null)
            this.resume()
            return
          }

          var self = this
          var unend = eos(readable, { writable: false, readable: true }, destroyer(this))

          var onreadable = function () {
            self._forward()
          }

          var onend = function () {
            self.push(null)
          }

          var clear = function () {
            self._readable2.removeListener('readable', onreadable)
            self._readable2.removeListener('end', onend)
            unend()
          }

          this._drained = true
          this._readable = readable
          this._readable2 = readable._readableState ? readable : toStreams2(readable)
          this._readable2.on('readable', onreadable)
          this._readable2.on('end', onend)
          this._unread = clear

          this._forward()
        }

        Duplexify.prototype._read = function () {
          this._drained = true
          this._forward()
        }

        Duplexify.prototype._forward = function () {
          if (this._forwarding || !this._readable2 || !this._drained) return
          this._forwarding = true

          var data

          while (this._drained && (data = shift(this._readable2)) !== null) {
            if (this.destroyed) continue
            this._drained = this.push(data)
          }

          this._forwarding = false
        }

        Duplexify.prototype.destroy = function (err) {
          if (this.destroyed) return
          this.destroyed = true

          var self = this
          process.nextTick(function () {
            self._destroy(err)
          })
        }

        Duplexify.prototype._destroy = function (err) {
          if (err) {
            var ondrain = this._ondrain
            this._ondrain = null
            if (ondrain) ondrain(err)
            else this.emit('error', err)
          }

          if (this._forwardDestroy) {
            if (this._readable && this._readable.destroy) this._readable.destroy()
            if (this._writable && this._writable.destroy) this._writable.destroy()
          }

          this.emit('close')
        }

        Duplexify.prototype._write = function (data, enc, cb) {
          if (this.destroyed) return cb()
          if (this._corked) return onuncork(this, this._write.bind(this, data, enc, cb))
          if (data === SIGNAL_FLUSH) return this._finish(cb)
          if (!this._writable) return cb()

          if (this._writable.write(data) === false) this._ondrain = cb
          else cb()
        }

        Duplexify.prototype._finish = function (cb) {
          var self = this
          this.emit('preend')
          onuncork(this, function () {
            end(self._forwardEnd && self._writable, function () {
              // haxx to not emit prefinish twice
              if (self._writableState.prefinished === false) self._writableState.prefinished = true
              self.emit('prefinish')
              onuncork(self, cb)
            })
          })
        }

        Duplexify.prototype.end = function (data, enc, cb) {
          if (typeof data === 'function') return this.end(null, null, data)
          if (typeof enc === 'function') return this.end(data, null, enc)
          this._ended = true
          if (data) this.write(data)
          if (!this._writableState.ending) this.write(SIGNAL_FLUSH)
          return stream.Writable.prototype.end.call(this, cb)
        }

        module.exports = Duplexify

      }).call(this, require('_process'), require("buffer").Buffer)
    }, { "_process": 100, "buffer": 12, "end-of-stream": 20, "inherits": 88, "readable-stream": 116, "stream-shift": 119 }], 20: [function (require, module, exports) {
      var once = require('once');

      var noop = function () { };

      var isRequest = function (stream) {
        return stream.setHeader && typeof stream.abort === 'function';
      };

      var isChildProcess = function (stream) {
        return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
      };

      var eos = function (stream, opts, callback) {
        if (typeof opts === 'function') return eos(stream, null, opts);
        if (!opts) opts = {};

        callback = once(callback || noop);

        var ws = stream._writableState;
        var rs = stream._readableState;
        var readable = opts.readable || (opts.readable !== false && stream.readable);
        var writable = opts.writable || (opts.writable !== false && stream.writable);

        var onlegacyfinish = function () {
          if (!stream.writable) onfinish();
        };

        var onfinish = function () {
          writable = false;
          if (!readable) callback.call(stream);
        };

        var onend = function () {
          readable = false;
          if (!writable) callback.call(stream);
        };

        var onexit = function (exitCode) {
          callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
        };

        var onerror = function (err) {
          callback.call(stream, err);
        };

        var onclose = function () {
          if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
          if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
        };

        var onrequest = function () {
          stream.req.on('finish', onfinish);
        };

        if (isRequest(stream)) {
          stream.on('complete', onfinish);
          stream.on('abort', onclose);
          if (stream.req) onrequest();
          else stream.on('request', onrequest);
        } else if (writable && !ws) { // legacy streams
          stream.on('end', onlegacyfinish);
          stream.on('close', onlegacyfinish);
        }

        if (isChildProcess(stream)) stream.on('exit', onexit);

        stream.on('end', onend);
        stream.on('finish', onfinish);
        if (opts.error !== false) stream.on('error', onerror);
        stream.on('close', onclose);

        return function () {
          stream.removeListener('complete', onfinish);
          stream.removeListener('abort', onclose);
          stream.removeListener('request', onrequest);
          if (stream.req) stream.req.removeListener('finish', onfinish);
          stream.removeListener('end', onlegacyfinish);
          stream.removeListener('close', onlegacyfinish);
          stream.removeListener('finish', onfinish);
          stream.removeListener('exit', onexit);
          stream.removeListener('end', onend);
          stream.removeListener('error', onerror);
          stream.removeListener('close', onclose);
        };
      };

      module.exports = eos;

    }, { "once": 98 }], 21: [function (require, module, exports) {
      // Inspired by Google Closure:
      // http://closure-library.googlecode.com/svn/docs/
      // closure_goog_array_array.js.html#goog.array.clear

      "use strict";

      var value = require("../../object/valid-value");

      module.exports = function () {
        value(this).length = 0;
        return this;
      };

    }, { "../../object/valid-value": 56 }], 22: [function (require, module, exports) {
      "use strict";

      var numberIsNaN = require("../../number/is-nan")
        , toPosInt = require("../../number/to-pos-integer")
        , value = require("../../object/valid-value")
        , indexOf = Array.prototype.indexOf
        , objHasOwnProperty = Object.prototype.hasOwnProperty
        , abs = Math.abs
        , floor = Math.floor;

      module.exports = function (searchElement/*, fromIndex*/) {
        var i, length, fromIndex, val;
        if (!numberIsNaN(searchElement)) return indexOf.apply(this, arguments);

        length = toPosInt(value(this).length);
        fromIndex = arguments[1];
        if (isNaN(fromIndex)) fromIndex = 0;
        else if (fromIndex >= 0) fromIndex = floor(fromIndex);
        else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));

        for (i = fromIndex; i < length; ++i) {
          if (objHasOwnProperty.call(this, i)) {
            val = this[i];
            if (numberIsNaN(val)) return i; // Jslint: ignore
          }
        }
        return -1;
      };

    }, { "../../number/is-nan": 32, "../../number/to-pos-integer": 36, "../../object/valid-value": 56 }], 23: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Array.from : require("./shim");

    }, { "./is-implemented": 24, "./shim": 25 }], 24: [function (require, module, exports) {
      "use strict";

      module.exports = function () {
        var from = Array.from, arr, result;
        if (typeof from !== "function") return false;
        arr = ["raz", "dwa"];
        result = from(arr);
        return Boolean(result && result !== arr && result[1] === "dwa");
      };

    }, {}], 25: [function (require, module, exports) {
      "use strict";

      var iteratorSymbol = require("es6-symbol").iterator
        , isArguments = require("../../function/is-arguments")
        , isFunction = require("../../function/is-function")
        , toPosInt = require("../../number/to-pos-integer")
        , callable = require("../../object/valid-callable")
        , validValue = require("../../object/valid-value")
        , isValue = require("../../object/is-value")
        , isString = require("../../string/is-string")
        , isArray = Array.isArray
        , call = Function.prototype.call
        , desc = { configurable: true, enumerable: true, writable: true, value: null }
        , defineProperty = Object.defineProperty;

      // eslint-disable-next-line complexity, max-lines-per-function
      module.exports = function (arrayLike/*, mapFn, thisArg*/) {
        var mapFn = arguments[1]
          , thisArg = arguments[2]
          , Context
          , i
          , j
          , arr
          , length
          , code
          , iterator
          , result
          , getIterator
          , value;

        arrayLike = Object(validValue(arrayLike));

        if (isValue(mapFn)) callable(mapFn);
        if (!this || this === Array || !isFunction(this)) {
          // Result: Plain array
          if (!mapFn) {
            if (isArguments(arrayLike)) {
              // Source: Arguments
              length = arrayLike.length;
              if (length !== 1) return Array.apply(null, arrayLike);
              arr = new Array(1);
              arr[0] = arrayLike[0];
              return arr;
            }
            if (isArray(arrayLike)) {
              // Source: Array
              arr = new Array((length = arrayLike.length));
              for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
              return arr;
            }
          }
          arr = [];
        } else {
          // Result: Non plain array
          Context = this;
        }

        if (!isArray(arrayLike)) {
          if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
            // Source: Iterator
            iterator = callable(getIterator).call(arrayLike);
            if (Context) arr = new Context();
            result = iterator.next();
            i = 0;
            while (!result.done) {
              value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
              if (Context) {
                desc.value = value;
                defineProperty(arr, i, desc);
              } else {
                arr[i] = value;
              }
              result = iterator.next();
              ++i;
            }
            length = i;
          } else if (isString(arrayLike)) {
            // Source: String
            length = arrayLike.length;
            if (Context) arr = new Context();
            for (i = 0, j = 0; i < length; ++i) {
              value = arrayLike[i];
              if (i + 1 < length) {
                code = value.charCodeAt(0);
                // eslint-disable-next-line max-depth
                if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
              }
              value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
              if (Context) {
                desc.value = value;
                defineProperty(arr, j, desc);
              } else {
                arr[j] = value;
              }
              ++j;
            }
            length = j;
          }
        }
        if (length === undefined) {
          // Source: array or array-like
          length = toPosInt(arrayLike.length);
          if (Context) arr = new Context(length);
          for (i = 0; i < length; ++i) {
            value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
            if (Context) {
              desc.value = value;
              defineProperty(arr, i, desc);
            } else {
              arr[i] = value;
            }
          }
        }
        if (Context) {
          desc.value = null;
          arr.length = length;
        }
        return arr;
      };

    }, { "../../function/is-arguments": 26, "../../function/is-function": 27, "../../number/to-pos-integer": 36, "../../object/is-value": 45, "../../object/valid-callable": 55, "../../object/valid-value": 56, "../../string/is-string": 60, "es6-symbol": 74 }], 26: [function (require, module, exports) {
      "use strict";

      var objToString = Object.prototype.toString
        , id = objToString.call((function () { return arguments; })());

      module.exports = function (value) { return objToString.call(value) === id; };

    }, {}], 27: [function (require, module, exports) {
      "use strict";

      var objToString = Object.prototype.toString
        , isFunctionStringTag = RegExp.prototype.test.bind(/^[object [A-Za-z0-9]*Function]$/);

      module.exports = function (value) {
        return typeof value === "function" && isFunctionStringTag(objToString.call(value));
      };

    }, {}], 28: [function (require, module, exports) {
      "use strict";

      // eslint-disable-next-line no-empty-function
      module.exports = function () { };

    }, {}], 29: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Math.sign : require("./shim");

    }, { "./is-implemented": 30, "./shim": 31 }], 30: [function (require, module, exports) {
      "use strict";

      module.exports = function () {
        var sign = Math.sign;
        if (typeof sign !== "function") return false;
        return sign(10) === 1 && sign(-20) === -1;
      };

    }, {}], 31: [function (require, module, exports) {
      "use strict";

      module.exports = function (value) {
        value = Number(value);
        if (isNaN(value) || value === 0) return value;
        return value > 0 ? 1 : -1;
      };

    }, {}], 32: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Number.isNaN : require("./shim");

    }, { "./is-implemented": 33, "./shim": 34 }], 33: [function (require, module, exports) {
      "use strict";

      module.exports = function () {
        var numberIsNaN = Number.isNaN;
        if (typeof numberIsNaN !== "function") return false;
        return !numberIsNaN({}) && numberIsNaN(NaN) && !numberIsNaN(34);
      };

    }, {}], 34: [function (require, module, exports) {
      "use strict";

      module.exports = function (value) {
        // eslint-disable-next-line no-self-compare
        return value !== value;
      };

    }, {}], 35: [function (require, module, exports) {
      "use strict";

      var sign = require("../math/sign")
        , abs = Math.abs
        , floor = Math.floor;

      module.exports = function (value) {
        if (isNaN(value)) return 0;
        value = Number(value);
        if (value === 0 || !isFinite(value)) return value;
        return sign(value) * floor(abs(value));
      };

    }, { "../math/sign": 29 }], 36: [function (require, module, exports) {
      "use strict";

      var toInteger = require("./to-integer")
        , max = Math.max;

      module.exports = function (value) { return max(0, toInteger(value)); };

    }, { "./to-integer": 35 }], 37: [function (require, module, exports) {
      // Internal method, used by iteration functions.
      // Calls a function for each key-value pair found in object
      // Optionally takes compareFn to iterate object in specific order

      "use strict";

      var callable = require("./valid-callable")
        , value = require("./valid-value")
        , bind = Function.prototype.bind
        , call = Function.prototype.call
        , keys = Object.keys
        , objPropertyIsEnumerable = Object.prototype.propertyIsEnumerable;

      module.exports = function (method, defVal) {
        return function (obj, cb/*, thisArg, compareFn*/) {
          var list, thisArg = arguments[2], compareFn = arguments[3];
          obj = Object(value(obj));
          callable(cb);

          list = keys(obj);
          if (compareFn) {
            list.sort(typeof compareFn === "function" ? bind.call(compareFn, obj) : undefined);
          }
          if (typeof method !== "function") method = list[method];
          return call.call(method, list, function (key, index) {
            if (!objPropertyIsEnumerable.call(obj, key)) return defVal;
            return call.call(cb, thisArg, obj[key], key, obj, index);
          });
        };
      };

    }, { "./valid-callable": 55, "./valid-value": 56 }], 38: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Object.assign : require("./shim");

    }, { "./is-implemented": 39, "./shim": 40 }], 39: [function (require, module, exports) {
      "use strict";

      module.exports = function () {
        var assign = Object.assign, obj;
        if (typeof assign !== "function") return false;
        obj = { foo: "raz" };
        assign(obj, { bar: "dwa" }, { trzy: "trzy" });
        return obj.foo + obj.bar + obj.trzy === "razdwatrzy";
      };

    }, {}], 40: [function (require, module, exports) {
      "use strict";

      var keys = require("../keys")
        , value = require("../valid-value")
        , max = Math.max;

      module.exports = function (dest, src/*, …srcn*/) {
        var error, i, length = max(arguments.length, 2), assign;
        dest = Object(value(dest));
        assign = function (key) {
          try {
            dest[key] = src[key];
          } catch (e) {
            if (!error) error = e;
          }
        };
        for (i = 1; i < length; ++i) {
          src = arguments[i];
          keys(src).forEach(assign);
        }
        if (error !== undefined) throw error;
        return dest;
      };

    }, { "../keys": 46, "../valid-value": 56 }], 41: [function (require, module, exports) {
      "use strict";

      var aFrom = require("../array/from")
        , assign = require("./assign")
        , value = require("./valid-value");

      module.exports = function (obj/*, propertyNames, options*/) {
        var copy = Object(value(obj)), propertyNames = arguments[1], options = Object(arguments[2]);
        if (copy !== obj && !propertyNames) return copy;
        var result = {};
        if (propertyNames) {
          aFrom(propertyNames, function (propertyName) {
            if (options.ensure || propertyName in obj) result[propertyName] = obj[propertyName];
          });
        } else {
          assign(result, obj);
        }
        return result;
      };

    }, { "../array/from": 23, "./assign": 38, "./valid-value": 56 }], 42: [function (require, module, exports) {
      // Workaround for http://code.google.com/p/v8/issues/detail?id=2804

      "use strict";

      var create = Object.create, shim;

      if (!require("./set-prototype-of/is-implemented")()) {
        shim = require("./set-prototype-of/shim");
      }

      module.exports = (function () {
        var nullObject, polyProps, desc;
        if (!shim) return create;
        if (shim.level !== 1) return create;

        nullObject = {};
        polyProps = {};
        desc = { configurable: false, enumerable: false, writable: true, value: undefined };
        Object.getOwnPropertyNames(Object.prototype).forEach(function (name) {
          if (name === "__proto__") {
            polyProps[name] = {
              configurable: true,
              enumerable: false,
              writable: true,
              value: undefined
            };
            return;
          }
          polyProps[name] = desc;
        });
        Object.defineProperties(nullObject, polyProps);

        Object.defineProperty(shim, "nullPolyfill", {
          configurable: false,
          enumerable: false,
          writable: false,
          value: nullObject
        });

        return function (prototype, props) {
          return create(prototype === null ? nullObject : prototype, props);
        };
      })();

    }, { "./set-prototype-of/is-implemented": 53, "./set-prototype-of/shim": 54 }], 43: [function (require, module, exports) {
      "use strict";

      module.exports = require("./_iterate")("forEach");

    }, { "./_iterate": 37 }], 44: [function (require, module, exports) {
      "use strict";

      var isValue = require("./is-value");

      var map = { function: true, object: true };

      module.exports = function (value) { return (isValue(value) && map[typeof value]) || false; };

    }, { "./is-value": 45 }], 45: [function (require, module, exports) {
      "use strict";

      var _undefined = require("../function/noop")(); // Support ES3 engines

      module.exports = function (val) { return val !== _undefined && val !== null; };

    }, { "../function/noop": 28 }], 46: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Object.keys : require("./shim");

    }, { "./is-implemented": 47, "./shim": 48 }], 47: [function (require, module, exports) {
      "use strict";

      module.exports = function () {
        try {
          Object.keys("primitive");
          return true;
        } catch (e) {
          return false;
        }
      };

    }, {}], 48: [function (require, module, exports) {
      "use strict";

      var isValue = require("../is-value");

      var keys = Object.keys;

      module.exports = function (object) { return keys(isValue(object) ? Object(object) : object); };

    }, { "../is-value": 45 }], 49: [function (require, module, exports) {
      "use strict";

      var callable = require("./valid-callable")
        , forEach = require("./for-each")
        , call = Function.prototype.call;

      module.exports = function (obj, cb/*, thisArg*/) {
        var result = {}, thisArg = arguments[2];
        callable(cb);
        forEach(obj, function (value, key, targetObj, index) {
          result[key] = call.call(cb, thisArg, value, key, targetObj, index);
        });
        return result;
      };

    }, { "./for-each": 43, "./valid-callable": 55 }], 50: [function (require, module, exports) {
      "use strict";

      var isValue = require("./is-value");

      var forEach = Array.prototype.forEach, create = Object.create;

      var process = function (src, obj) {
        var key;
        for (key in src) obj[key] = src[key];
      };

      // eslint-disable-next-line no-unused-vars
      module.exports = function (opts1/*, …options*/) {
        var result = create(null);
        forEach.call(arguments, function (options) {
          if (!isValue(options)) return;
          process(Object(options), result);
        });
        return result;
      };

    }, { "./is-value": 45 }], 51: [function (require, module, exports) {
      "use strict";

      var forEach = Array.prototype.forEach, create = Object.create;

      // eslint-disable-next-line no-unused-vars
      module.exports = function (arg/*, …args*/) {
        var set = create(null);
        forEach.call(arguments, function (name) { set[name] = true; });
        return set;
      };

    }, {}], 52: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Object.setPrototypeOf : require("./shim");

    }, { "./is-implemented": 53, "./shim": 54 }], 53: [function (require, module, exports) {
      "use strict";

      var create = Object.create, getPrototypeOf = Object.getPrototypeOf, plainObject = {};

      module.exports = function (/* CustomCreate*/) {
        var setPrototypeOf = Object.setPrototypeOf, customCreate = arguments[0] || create;
        if (typeof setPrototypeOf !== "function") return false;
        return getPrototypeOf(setPrototypeOf(customCreate(null), plainObject)) === plainObject;
      };

    }, {}], 54: [function (require, module, exports) {
      /* eslint no-proto: "off" */

      // Big thanks to @WebReflection for sorting this out
      // https://gist.github.com/WebReflection/5593554

      "use strict";

      var isObject = require("../is-object")
        , value = require("../valid-value")
        , objIsPrototypeOf = Object.prototype.isPrototypeOf
        , defineProperty = Object.defineProperty
        , nullDesc = { configurable: true, enumerable: false, writable: true, value: undefined }
        , validate;

      validate = function (obj, prototype) {
        value(obj);
        if (prototype === null || isObject(prototype)) return obj;
        throw new TypeError("Prototype must be null or an object");
      };

      module.exports = (function (status) {
        var fn, set;
        if (!status) return null;
        if (status.level === 2) {
          if (status.set) {
            set = status.set;
            fn = function (obj, prototype) {
              set.call(validate(obj, prototype), prototype);
              return obj;
            };
          } else {
            fn = function (obj, prototype) {
              validate(obj, prototype).__proto__ = prototype;
              return obj;
            };
          }
        } else {
          fn = function self(obj, prototype) {
            var isNullBase;
            validate(obj, prototype);
            isNullBase = objIsPrototypeOf.call(self.nullPolyfill, obj);
            if (isNullBase) delete self.nullPolyfill.__proto__;
            if (prototype === null) prototype = self.nullPolyfill;
            obj.__proto__ = prototype;
            if (isNullBase) defineProperty(self.nullPolyfill, "__proto__", nullDesc);
            return obj;
          };
        }
        return Object.defineProperty(fn, "level", {
          configurable: false,
          enumerable: false,
          writable: false,
          value: status.level
        });
      })(
        (function () {
          var tmpObj1 = Object.create(null)
            , tmpObj2 = {}
            , set
            , desc = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");

          if (desc) {
            try {
              set = desc.set; // Opera crashes at this point
              set.call(tmpObj1, tmpObj2);
            } catch (ignore) { }
            if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { set: set, level: 2 };
          }

          tmpObj1.__proto__ = tmpObj2;
          if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 2 };

          tmpObj1 = {};
          tmpObj1.__proto__ = tmpObj2;
          if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 1 };

          return false;
        })()
      );

      require("../create");

    }, { "../create": 42, "../is-object": 44, "../valid-value": 56 }], 55: [function (require, module, exports) {
      "use strict";

      module.exports = function (fn) {
        if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
        return fn;
      };

    }, {}], 56: [function (require, module, exports) {
      "use strict";

      var isValue = require("./is-value");

      module.exports = function (value) {
        if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
        return value;
      };

    }, { "./is-value": 45 }], 57: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? String.prototype.contains : require("./shim");

    }, { "./is-implemented": 58, "./shim": 59 }], 58: [function (require, module, exports) {
      "use strict";

      var str = "razdwatrzy";

      module.exports = function () {
        if (typeof str.contains !== "function") return false;
        return str.contains("dwa") === true && str.contains("foo") === false;
      };

    }, {}], 59: [function (require, module, exports) {
      "use strict";

      var indexOf = String.prototype.indexOf;

      module.exports = function (searchString/*, position*/) {
        return indexOf.call(this, searchString, arguments[1]) > -1;
      };

    }, {}], 60: [function (require, module, exports) {
      "use strict";

      var objToString = Object.prototype.toString, id = objToString.call("");

      module.exports = function (value) {
        return (
          typeof value === "string" ||
          (value &&
            typeof value === "object" &&
            (value instanceof String || objToString.call(value) === id)) ||
          false
        );
      };

    }, {}], 61: [function (require, module, exports) {
      "use strict";

      var setPrototypeOf = require("es5-ext/object/set-prototype-of")
        , contains = require("es5-ext/string/#/contains")
        , d = require("d")
        , Symbol = require("es6-symbol")
        , Iterator = require("./");

      var defineProperty = Object.defineProperty, ArrayIterator;

      ArrayIterator = module.exports = function (arr, kind) {
        if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
        Iterator.call(this, arr);
        if (!kind) kind = "value";
        else if (contains.call(kind, "key+value")) kind = "key+value";
        else if (contains.call(kind, "key")) kind = "key";
        else kind = "value";
        defineProperty(this, "__kind__", d("", kind));
      };
      if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);

      // Internal %ArrayIteratorPrototype% doesn't expose its constructor
      delete ArrayIterator.prototype.constructor;

      ArrayIterator.prototype = Object.create(Iterator.prototype, {
        _resolve: d(function (i) {
          if (this.__kind__ === "value") return this.__list__[i];
          if (this.__kind__ === "key+value") return [i, this.__list__[i]];
          return i;
        })
      });
      defineProperty(ArrayIterator.prototype, Symbol.toStringTag, d("c", "Array Iterator"));

    }, { "./": 64, "d": 15, "es5-ext/object/set-prototype-of": 52, "es5-ext/string/#/contains": 57, "es6-symbol": 74 }], 62: [function (require, module, exports) {
      "use strict";

      var isArguments = require("es5-ext/function/is-arguments")
        , callable = require("es5-ext/object/valid-callable")
        , isString = require("es5-ext/string/is-string")
        , get = require("./get");

      var isArray = Array.isArray, call = Function.prototype.call, some = Array.prototype.some;

      module.exports = function (iterable, cb /*, thisArg*/) {
        var mode, thisArg = arguments[2], result, doBreak, broken, i, length, char, code;
        if (isArray(iterable) || isArguments(iterable)) mode = "array";
        else if (isString(iterable)) mode = "string";
        else iterable = get(iterable);

        callable(cb);
        doBreak = function () {
          broken = true;
        };
        if (mode === "array") {
          some.call(iterable, function (value) {
            call.call(cb, thisArg, value, doBreak);
            return broken;
          });
          return;
        }
        if (mode === "string") {
          length = iterable.length;
          for (i = 0; i < length; ++i) {
            char = iterable[i];
            if (i + 1 < length) {
              code = char.charCodeAt(0);
              if (code >= 0xd800 && code <= 0xdbff) char += iterable[++i];
            }
            call.call(cb, thisArg, char, doBreak);
            if (broken) break;
          }
          return;
        }
        result = iterable.next();

        while (!result.done) {
          call.call(cb, thisArg, result.value, doBreak);
          if (broken) return;
          result = iterable.next();
        }
      };

    }, { "./get": 63, "es5-ext/function/is-arguments": 26, "es5-ext/object/valid-callable": 55, "es5-ext/string/is-string": 60 }], 63: [function (require, module, exports) {
      "use strict";

      var isArguments = require("es5-ext/function/is-arguments")
        , isString = require("es5-ext/string/is-string")
        , ArrayIterator = require("./array")
        , StringIterator = require("./string")
        , iterable = require("./valid-iterable")
        , iteratorSymbol = require("es6-symbol").iterator;

      module.exports = function (obj) {
        if (typeof iterable(obj)[iteratorSymbol] === "function") return obj[iteratorSymbol]();
        if (isArguments(obj)) return new ArrayIterator(obj);
        if (isString(obj)) return new StringIterator(obj);
        return new ArrayIterator(obj);
      };

    }, { "./array": 61, "./string": 66, "./valid-iterable": 67, "es5-ext/function/is-arguments": 26, "es5-ext/string/is-string": 60, "es6-symbol": 74 }], 64: [function (require, module, exports) {
      "use strict";

      var clear = require("es5-ext/array/#/clear")
        , assign = require("es5-ext/object/assign")
        , callable = require("es5-ext/object/valid-callable")
        , value = require("es5-ext/object/valid-value")
        , d = require("d")
        , autoBind = require("d/auto-bind")
        , Symbol = require("es6-symbol");

      var defineProperty = Object.defineProperty, defineProperties = Object.defineProperties, Iterator;

      module.exports = Iterator = function (list, context) {
        if (!(this instanceof Iterator)) throw new TypeError("Constructor requires 'new'");
        defineProperties(this, {
          __list__: d("w", value(list)),
          __context__: d("w", context),
          __nextIndex__: d("w", 0)
        });
        if (!context) return;
        callable(context.on);
        context.on("_add", this._onAdd);
        context.on("_delete", this._onDelete);
        context.on("_clear", this._onClear);
      };

      // Internal %IteratorPrototype% doesn't expose its constructor
      delete Iterator.prototype.constructor;

      defineProperties(
        Iterator.prototype,
        assign(
          {
            _next: d(function () {
              var i;
              if (!this.__list__) return undefined;
              if (this.__redo__) {
                i = this.__redo__.shift();
                if (i !== undefined) return i;
              }
              if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
              this._unBind();
              return undefined;
            }),
            next: d(function () {
              return this._createResult(this._next());
            }),
            _createResult: d(function (i) {
              if (i === undefined) return { done: true, value: undefined };
              return { done: false, value: this._resolve(i) };
            }),
            _resolve: d(function (i) {
              return this.__list__[i];
            }),
            _unBind: d(function () {
              this.__list__ = null;
              delete this.__redo__;
              if (!this.__context__) return;
              this.__context__.off("_add", this._onAdd);
              this.__context__.off("_delete", this._onDelete);
              this.__context__.off("_clear", this._onClear);
              this.__context__ = null;
            }),
            toString: d(function () {
              return "[object " + (this[Symbol.toStringTag] || "Object") + "]";
            })
          },
          autoBind({
            _onAdd: d(function (index) {
              if (index >= this.__nextIndex__) return;
              ++this.__nextIndex__;
              if (!this.__redo__) {
                defineProperty(this, "__redo__", d("c", [index]));
                return;
              }
              this.__redo__.forEach(function (redo, i) {
                if (redo >= index) this.__redo__[i] = ++redo;
              }, this);
              this.__redo__.push(index);
            }),
            _onDelete: d(function (index) {
              var i;
              if (index >= this.__nextIndex__) return;
              --this.__nextIndex__;
              if (!this.__redo__) return;
              i = this.__redo__.indexOf(index);
              if (i !== -1) this.__redo__.splice(i, 1);
              this.__redo__.forEach(function (redo, j) {
                if (redo > index) this.__redo__[j] = --redo;
              }, this);
            }),
            _onClear: d(function () {
              if (this.__redo__) clear.call(this.__redo__);
              this.__nextIndex__ = 0;
            })
          })
        )
      );

      defineProperty(
        Iterator.prototype,
        Symbol.iterator,
        d(function () {
          return this;
        })
      );

    }, { "d": 15, "d/auto-bind": 14, "es5-ext/array/#/clear": 21, "es5-ext/object/assign": 38, "es5-ext/object/valid-callable": 55, "es5-ext/object/valid-value": 56, "es6-symbol": 74 }], 65: [function (require, module, exports) {
      "use strict";

      var isArguments = require("es5-ext/function/is-arguments")
        , isValue = require("es5-ext/object/is-value")
        , isString = require("es5-ext/string/is-string");

      var iteratorSymbol = require("es6-symbol").iterator
        , isArray = Array.isArray;

      module.exports = function (value) {
        if (!isValue(value)) return false;
        if (isArray(value)) return true;
        if (isString(value)) return true;
        if (isArguments(value)) return true;
        return typeof value[iteratorSymbol] === "function";
      };

    }, { "es5-ext/function/is-arguments": 26, "es5-ext/object/is-value": 45, "es5-ext/string/is-string": 60, "es6-symbol": 74 }], 66: [function (require, module, exports) {
      // Thanks @mathiasbynens
      // http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols

      "use strict";

      var setPrototypeOf = require("es5-ext/object/set-prototype-of")
        , d = require("d")
        , Symbol = require("es6-symbol")
        , Iterator = require("./");

      var defineProperty = Object.defineProperty, StringIterator;

      StringIterator = module.exports = function (str) {
        if (!(this instanceof StringIterator)) throw new TypeError("Constructor requires 'new'");
        str = String(str);
        Iterator.call(this, str);
        defineProperty(this, "__length__", d("", str.length));
      };
      if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);

      // Internal %ArrayIteratorPrototype% doesn't expose its constructor
      delete StringIterator.prototype.constructor;

      StringIterator.prototype = Object.create(Iterator.prototype, {
        _next: d(function () {
          if (!this.__list__) return undefined;
          if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
          this._unBind();
          return undefined;
        }),
        _resolve: d(function (i) {
          var char = this.__list__[i], code;
          if (this.__nextIndex__ === this.__length__) return char;
          code = char.charCodeAt(0);
          if (code >= 0xd800 && code <= 0xdbff) return char + this.__list__[this.__nextIndex__++];
          return char;
        })
      });
      defineProperty(StringIterator.prototype, Symbol.toStringTag, d("c", "String Iterator"));

    }, { "./": 64, "d": 15, "es5-ext/object/set-prototype-of": 52, "es6-symbol": 74 }], 67: [function (require, module, exports) {
      "use strict";

      var isIterable = require("./is-iterable");

      module.exports = function (value) {
        if (!isIterable(value)) throw new TypeError(value + " is not iterable");
        return value;
      };

    }, { "./is-iterable": 65 }], 68: [function (require, module, exports) {
      'use strict';

      module.exports = require('./is-implemented')() ? Map : require('./polyfill');

    }, { "./is-implemented": 69, "./polyfill": 73 }], 69: [function (require, module, exports) {
      'use strict';

      module.exports = function () {
        var map, iterator, result;
        if (typeof Map !== 'function') return false;
        try {
          // WebKit doesn't support arguments and crashes
          map = new Map([['raz', 'one'], ['dwa', 'two'], ['trzy', 'three']]);
        } catch (e) {
          return false;
        }
        if (String(map) !== '[object Map]') return false;
        if (map.size !== 3) return false;
        if (typeof map.clear !== 'function') return false;
        if (typeof map.delete !== 'function') return false;
        if (typeof map.entries !== 'function') return false;
        if (typeof map.forEach !== 'function') return false;
        if (typeof map.get !== 'function') return false;
        if (typeof map.has !== 'function') return false;
        if (typeof map.keys !== 'function') return false;
        if (typeof map.set !== 'function') return false;
        if (typeof map.values !== 'function') return false;

        iterator = map.entries();
        result = iterator.next();
        if (result.done !== false) return false;
        if (!result.value) return false;
        if (result.value[0] !== 'raz') return false;
        if (result.value[1] !== 'one') return false;

        return true;
      };

    }, {}], 70: [function (require, module, exports) {
      // Exports true if environment provides native `Map` implementation,
      // whatever that is.

      'use strict';

      module.exports = (function () {
        if (typeof Map === 'undefined') return false;
        return (Object.prototype.toString.call(new Map()) === '[object Map]');
      }());

    }, {}], 71: [function (require, module, exports) {
      'use strict';

      module.exports = require('es5-ext/object/primitive-set')('key',
        'value', 'key+value');

    }, { "es5-ext/object/primitive-set": 51 }], 72: [function (require, module, exports) {
      'use strict';

      var setPrototypeOf = require('es5-ext/object/set-prototype-of')
        , d = require('d')
        , Iterator = require('es6-iterator')
        , toStringTagSymbol = require('es6-symbol').toStringTag
        , kinds = require('./iterator-kinds')

        , defineProperties = Object.defineProperties
        , unBind = Iterator.prototype._unBind
        , MapIterator;

      MapIterator = module.exports = function (map, kind) {
        if (!(this instanceof MapIterator)) return new MapIterator(map, kind);
        Iterator.call(this, map.__mapKeysData__, map);
        if (!kind || !kinds[kind]) kind = 'key+value';
        defineProperties(this, {
          __kind__: d('', kind),
          __values__: d('w', map.__mapValuesData__)
        });
      };
      if (setPrototypeOf) setPrototypeOf(MapIterator, Iterator);

      MapIterator.prototype = Object.create(Iterator.prototype, {
        constructor: d(MapIterator),
        _resolve: d(function (i) {
          if (this.__kind__ === 'value') return this.__values__[i];
          if (this.__kind__ === 'key') return this.__list__[i];
          return [this.__list__[i], this.__values__[i]];
        }),
        _unBind: d(function () {
          this.__values__ = null;
          unBind.call(this);
        }),
        toString: d(function () { return '[object Map Iterator]'; })
      });
      Object.defineProperty(MapIterator.prototype, toStringTagSymbol,
        d('c', 'Map Iterator'));

    }, { "./iterator-kinds": 71, "d": 15, "es5-ext/object/set-prototype-of": 52, "es6-iterator": 64, "es6-symbol": 74 }], 73: [function (require, module, exports) {
      'use strict';

      var clear = require('es5-ext/array/#/clear')
        , eIndexOf = require('es5-ext/array/#/e-index-of')
        , setPrototypeOf = require('es5-ext/object/set-prototype-of')
        , callable = require('es5-ext/object/valid-callable')
        , validValue = require('es5-ext/object/valid-value')
        , d = require('d')
        , ee = require('event-emitter')
        , Symbol = require('es6-symbol')
        , iterator = require('es6-iterator/valid-iterable')
        , forOf = require('es6-iterator/for-of')
        , Iterator = require('./lib/iterator')
        , isNative = require('./is-native-implemented')

        , call = Function.prototype.call
        , defineProperties = Object.defineProperties, getPrototypeOf = Object.getPrototypeOf
        , MapPoly;

      module.exports = MapPoly = function (/*iterable*/) {
        var iterable = arguments[0], keys, values, self;
        if (!(this instanceof MapPoly)) throw new TypeError('Constructor requires \'new\'');
        if (isNative && setPrototypeOf && (Map !== MapPoly)) {
          self = setPrototypeOf(new Map(), getPrototypeOf(this));
        } else {
          self = this;
        }
        if (iterable != null) iterator(iterable);
        defineProperties(self, {
          __mapKeysData__: d('c', keys = []),
          __mapValuesData__: d('c', values = [])
        });
        if (!iterable) return self;
        forOf(iterable, function (value) {
          var key = validValue(value)[0];
          value = value[1];
          if (eIndexOf.call(keys, key) !== -1) return;
          keys.push(key);
          values.push(value);
        }, self);
        return self;
      };

      if (isNative) {
        if (setPrototypeOf) setPrototypeOf(MapPoly, Map);
        MapPoly.prototype = Object.create(Map.prototype, {
          constructor: d(MapPoly)
        });
      }

      ee(defineProperties(MapPoly.prototype, {
        clear: d(function () {
          if (!this.__mapKeysData__.length) return;
          clear.call(this.__mapKeysData__);
          clear.call(this.__mapValuesData__);
          this.emit('_clear');
        }),
        delete: d(function (key) {
          var index = eIndexOf.call(this.__mapKeysData__, key);
          if (index === -1) return false;
          this.__mapKeysData__.splice(index, 1);
          this.__mapValuesData__.splice(index, 1);
          this.emit('_delete', index, key);
          return true;
        }),
        entries: d(function () { return new Iterator(this, 'key+value'); }),
        forEach: d(function (cb/*, thisArg*/) {
          var thisArg = arguments[1], iterator, result;
          callable(cb);
          iterator = this.entries();
          result = iterator._next();
          while (result !== undefined) {
            call.call(cb, thisArg, this.__mapValuesData__[result],
              this.__mapKeysData__[result], this);
            result = iterator._next();
          }
        }),
        get: d(function (key) {
          var index = eIndexOf.call(this.__mapKeysData__, key);
          if (index === -1) return;
          return this.__mapValuesData__[index];
        }),
        has: d(function (key) {
          return (eIndexOf.call(this.__mapKeysData__, key) !== -1);
        }),
        keys: d(function () { return new Iterator(this, 'key'); }),
        set: d(function (key, value) {
          var index = eIndexOf.call(this.__mapKeysData__, key), emit;
          if (index === -1) {
            index = this.__mapKeysData__.push(key) - 1;
            emit = true;
          }
          this.__mapValuesData__[index] = value;
          if (emit) this.emit('_add', index, key);
          return this;
        }),
        size: d.gs(function () { return this.__mapKeysData__.length; }),
        values: d(function () { return new Iterator(this, 'value'); }),
        toString: d(function () { return '[object Map]'; })
      }));
      Object.defineProperty(MapPoly.prototype, Symbol.iterator, d(function () {
        return this.entries();
      }));
      Object.defineProperty(MapPoly.prototype, Symbol.toStringTag, d('c', 'Map'));

    }, { "./is-native-implemented": 70, "./lib/iterator": 72, "d": 15, "es5-ext/array/#/clear": 21, "es5-ext/array/#/e-index-of": 22, "es5-ext/object/set-prototype-of": 52, "es5-ext/object/valid-callable": 55, "es5-ext/object/valid-value": 56, "es6-iterator/for-of": 62, "es6-iterator/valid-iterable": 67, "es6-symbol": 74, "event-emitter": 82 }], 74: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")()
        ? require("ext/global-this").Symbol
        : require("./polyfill");

    }, { "./is-implemented": 75, "./polyfill": 80, "ext/global-this": 85 }], 75: [function (require, module, exports) {
      "use strict";

      var global = require("ext/global-this")
        , validTypes = { object: true, symbol: true };

      module.exports = function () {
        var Symbol = global.Symbol;
        var symbol;
        if (typeof Symbol !== "function") return false;
        symbol = Symbol("test symbol");
        try { String(symbol); }
        catch (e) { return false; }

        // Return 'true' also for polyfills
        if (!validTypes[typeof Symbol.iterator]) return false;
        if (!validTypes[typeof Symbol.toPrimitive]) return false;
        if (!validTypes[typeof Symbol.toStringTag]) return false;

        return true;
      };

    }, { "ext/global-this": 85 }], 76: [function (require, module, exports) {
      "use strict";

      module.exports = function (value) {
        if (!value) return false;
        if (typeof value === "symbol") return true;
        if (!value.constructor) return false;
        if (value.constructor.name !== "Symbol") return false;
        return value[value.constructor.toStringTag] === "Symbol";
      };

    }, {}], 77: [function (require, module, exports) {
      "use strict";

      var d = require("d");

      var create = Object.create, defineProperty = Object.defineProperty, objPrototype = Object.prototype;

      var created = create(null);
      module.exports = function (desc) {
        var postfix = 0, name, ie11BugWorkaround;
        while (created[desc + (postfix || "")]) ++postfix;
        desc += postfix || "";
        created[desc] = true;
        name = "@@" + desc;
        defineProperty(
          objPrototype,
          name,
          d.gs(null, function (value) {
            // For IE11 issue see:
            // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
            //    ie11-broken-getters-on-dom-objects
            // https://github.com/medikoo/es6-symbol/issues/12
            if (ie11BugWorkaround) return;
            ie11BugWorkaround = true;
            defineProperty(this, name, d(value));
            ie11BugWorkaround = false;
          })
        );
        return name;
      };

    }, { "d": 15 }], 78: [function (require, module, exports) {
      "use strict";

      var d = require("d")
        , NativeSymbol = require("ext/global-this").Symbol;

      module.exports = function (SymbolPolyfill) {
        return Object.defineProperties(SymbolPolyfill, {
          // To ensure proper interoperability with other native functions (e.g. Array.from)
          // fallback to eventual native implementation of given symbol
          hasInstance: d(
            "", (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill("hasInstance")
          ),
          isConcatSpreadable: d(
            "",
            (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
            SymbolPolyfill("isConcatSpreadable")
          ),
          iterator: d("", (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill("iterator")),
          match: d("", (NativeSymbol && NativeSymbol.match) || SymbolPolyfill("match")),
          replace: d("", (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill("replace")),
          search: d("", (NativeSymbol && NativeSymbol.search) || SymbolPolyfill("search")),
          species: d("", (NativeSymbol && NativeSymbol.species) || SymbolPolyfill("species")),
          split: d("", (NativeSymbol && NativeSymbol.split) || SymbolPolyfill("split")),
          toPrimitive: d(
            "", (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill("toPrimitive")
          ),
          toStringTag: d(
            "", (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill("toStringTag")
          ),
          unscopables: d(
            "", (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill("unscopables")
          )
        });
      };

    }, { "d": 15, "ext/global-this": 85 }], 79: [function (require, module, exports) {
      "use strict";

      var d = require("d")
        , validateSymbol = require("../../../validate-symbol");

      var registry = Object.create(null);

      module.exports = function (SymbolPolyfill) {
        return Object.defineProperties(SymbolPolyfill, {
          for: d(function (key) {
            if (registry[key]) return registry[key];
            return (registry[key] = SymbolPolyfill(String(key)));
          }),
          keyFor: d(function (symbol) {
            var key;
            validateSymbol(symbol);
            for (key in registry) {
              if (registry[key] === symbol) return key;
            }
            return undefined;
          })
        });
      };

    }, { "../../../validate-symbol": 81, "d": 15 }], 80: [function (require, module, exports) {
      // ES2015 Symbol polyfill for environments that do not (or partially) support it

      "use strict";

      var d = require("d")
        , validateSymbol = require("./validate-symbol")
        , NativeSymbol = require("ext/global-this").Symbol
        , generateName = require("./lib/private/generate-name")
        , setupStandardSymbols = require("./lib/private/setup/standard-symbols")
        , setupSymbolRegistry = require("./lib/private/setup/symbol-registry");

      var create = Object.create
        , defineProperties = Object.defineProperties
        , defineProperty = Object.defineProperty;

      var SymbolPolyfill, HiddenSymbol, isNativeSafe;

      if (typeof NativeSymbol === "function") {
        try {
          String(NativeSymbol());
          isNativeSafe = true;
        } catch (ignore) { }
      } else {
        NativeSymbol = null;
      }

      // Internal constructor (not one exposed) for creating Symbol instances.
      // This one is used to ensure that `someSymbol instanceof Symbol` always return false
      HiddenSymbol = function Symbol(description) {
        if (this instanceof HiddenSymbol) throw new TypeError("Symbol is not a constructor");
        return SymbolPolyfill(description);
      };

      // Exposed `Symbol` constructor
      // (returns instances of HiddenSymbol)
      module.exports = SymbolPolyfill = function Symbol(description) {
        var symbol;
        if (this instanceof Symbol) throw new TypeError("Symbol is not a constructor");
        if (isNativeSafe) return NativeSymbol(description);
        symbol = create(HiddenSymbol.prototype);
        description = description === undefined ? "" : String(description);
        return defineProperties(symbol, {
          __description__: d("", description),
          __name__: d("", generateName(description))
        });
      };

      setupStandardSymbols(SymbolPolyfill);
      setupSymbolRegistry(SymbolPolyfill);

      // Internal tweaks for real symbol producer
      defineProperties(HiddenSymbol.prototype, {
        constructor: d(SymbolPolyfill),
        toString: d("", function () { return this.__name__; })
      });

      // Proper implementation of methods exposed on Symbol.prototype
      // They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
      defineProperties(SymbolPolyfill.prototype, {
        toString: d(function () { return "Symbol (" + validateSymbol(this).__description__ + ")"; }),
        valueOf: d(function () { return validateSymbol(this); })
      });
      defineProperty(
        SymbolPolyfill.prototype,
        SymbolPolyfill.toPrimitive,
        d("", function () {
          var symbol = validateSymbol(this);
          if (typeof symbol === "symbol") return symbol;
          return symbol.toString();
        })
      );
      defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d("c", "Symbol"));

      // Proper implementaton of toPrimitive and toStringTag for returned symbol instances
      defineProperty(
        HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
        d("c", SymbolPolyfill.prototype[SymbolPolyfill.toStringTag])
      );

      // Note: It's important to define `toPrimitive` as last one, as some implementations
      // implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
      // And that may invoke error in definition flow:
      // See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
      defineProperty(
        HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
        d("c", SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive])
      );

    }, { "./lib/private/generate-name": 77, "./lib/private/setup/standard-symbols": 78, "./lib/private/setup/symbol-registry": 79, "./validate-symbol": 81, "d": 15, "ext/global-this": 85 }], 81: [function (require, module, exports) {
      "use strict";

      var isSymbol = require("./is-symbol");

      module.exports = function (value) {
        if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
        return value;
      };

    }, { "./is-symbol": 76 }], 82: [function (require, module, exports) {
      'use strict';

      var d = require('d')
        , callable = require('es5-ext/object/valid-callable')

        , apply = Function.prototype.apply, call = Function.prototype.call
        , create = Object.create, defineProperty = Object.defineProperty
        , defineProperties = Object.defineProperties
        , hasOwnProperty = Object.prototype.hasOwnProperty
        , descriptor = { configurable: true, enumerable: false, writable: true }

        , on, once, off, emit, methods, descriptors, base;

      on = function (type, listener) {
        var data;

        callable(listener);

        if (!hasOwnProperty.call(this, '__ee__')) {
          data = descriptor.value = create(null);
          defineProperty(this, '__ee__', descriptor);
          descriptor.value = null;
        } else {
          data = this.__ee__;
        }
        if (!data[type]) data[type] = listener;
        else if (typeof data[type] === 'object') data[type].push(listener);
        else data[type] = [data[type], listener];

        return this;
      };

      once = function (type, listener) {
        var once, self;

        callable(listener);
        self = this;
        on.call(this, type, once = function () {
          off.call(self, type, once);
          apply.call(listener, this, arguments);
        });

        once.__eeOnceListener__ = listener;
        return this;
      };

      off = function (type, listener) {
        var data, listeners, candidate, i;

        callable(listener);

        if (!hasOwnProperty.call(this, '__ee__')) return this;
        data = this.__ee__;
        if (!data[type]) return this;
        listeners = data[type];

        if (typeof listeners === 'object') {
          for (i = 0; (candidate = listeners[i]); ++i) {
            if ((candidate === listener) ||
              (candidate.__eeOnceListener__ === listener)) {
              if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
              else listeners.splice(i, 1);
            }
          }
        } else {
          if ((listeners === listener) ||
            (listeners.__eeOnceListener__ === listener)) {
            delete data[type];
          }
        }

        return this;
      };

      emit = function (type) {
        var i, l, listener, listeners, args;

        if (!hasOwnProperty.call(this, '__ee__')) return;
        listeners = this.__ee__[type];
        if (!listeners) return;

        if (typeof listeners === 'object') {
          l = arguments.length;
          args = new Array(l - 1);
          for (i = 1; i < l; ++i) args[i - 1] = arguments[i];

          listeners = listeners.slice();
          for (i = 0; (listener = listeners[i]); ++i) {
            apply.call(listener, this, args);
          }
        } else {
          switch (arguments.length) {
            case 1:
              call.call(listeners, this);
              break;
            case 2:
              call.call(listeners, this, arguments[1]);
              break;
            case 3:
              call.call(listeners, this, arguments[1], arguments[2]);
              break;
            default:
              l = arguments.length;
              args = new Array(l - 1);
              for (i = 1; i < l; ++i) {
                args[i - 1] = arguments[i];
              }
              apply.call(listeners, this, args);
          }
        }
      };

      methods = {
        on: on,
        once: once,
        off: off,
        emit: emit
      };

      descriptors = {
        on: d(on),
        once: d(once),
        off: d(off),
        emit: d(emit)
      };

      base = defineProperties({}, descriptors);

      module.exports = exports = function (o) {
        return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
      };
      exports.methods = methods;

    }, { "d": 15, "es5-ext/object/valid-callable": 55 }], 83: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      var objectCreate = Object.create || objectCreatePolyfill
      var objectKeys = Object.keys || objectKeysPolyfill
      var bind = Function.prototype.bind || functionBindPolyfill

      function EventEmitter() {
        if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
          this._events = objectCreate(null);
          this._eventsCount = 0;
        }

        this._maxListeners = this._maxListeners || undefined;
      }
      module.exports = EventEmitter;

      // Backwards-compat with node 0.10.x
      EventEmitter.EventEmitter = EventEmitter;

      EventEmitter.prototype._events = undefined;
      EventEmitter.prototype._maxListeners = undefined;

      // By default EventEmitters will print a warning if more than 10 listeners are
      // added to it. This is a useful default which helps finding memory leaks.
      var defaultMaxListeners = 10;

      var hasDefineProperty;
      try {
        var o = {};
        if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
        hasDefineProperty = o.x === 0;
      } catch (err) { hasDefineProperty = false }
      if (hasDefineProperty) {
        Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
          enumerable: true,
          get: function () {
            return defaultMaxListeners;
          },
          set: function (arg) {
            // check whether the input is a positive number (whose value is zero or
            // greater and not a NaN).
            if (typeof arg !== 'number' || arg < 0 || arg !== arg)
              throw new TypeError('"defaultMaxListeners" must be a positive number');
            defaultMaxListeners = arg;
          }
        });
      } else {
        EventEmitter.defaultMaxListeners = defaultMaxListeners;
      }

      // Obviously not all Emitters should be limited to 10. This function allows
      // that to be increased. Set to zero for unlimited.
      EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
        if (typeof n !== 'number' || n < 0 || isNaN(n))
          throw new TypeError('"n" argument must be a positive number');
        this._maxListeners = n;
        return this;
      };

      function $getMaxListeners(that) {
        if (that._maxListeners === undefined)
          return EventEmitter.defaultMaxListeners;
        return that._maxListeners;
      }

      EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
        return $getMaxListeners(this);
      };

      // These standalone emit* functions are used to optimize calling of event
      // handlers for fast cases because emit() itself often has a variable number of
      // arguments and can be deoptimized because of that. These functions always have
      // the same number of arguments and thus do not get deoptimized, so the code
      // inside them can execute faster.
      function emitNone(handler, isFn, self) {
        if (isFn)
          handler.call(self);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self);
        }
      }
      function emitOne(handler, isFn, self, arg1) {
        if (isFn)
          handler.call(self, arg1);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self, arg1);
        }
      }
      function emitTwo(handler, isFn, self, arg1, arg2) {
        if (isFn)
          handler.call(self, arg1, arg2);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self, arg1, arg2);
        }
      }
      function emitThree(handler, isFn, self, arg1, arg2, arg3) {
        if (isFn)
          handler.call(self, arg1, arg2, arg3);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self, arg1, arg2, arg3);
        }
      }

      function emitMany(handler, isFn, self, args) {
        if (isFn)
          handler.apply(self, args);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].apply(self, args);
        }
      }

      EventEmitter.prototype.emit = function emit(type) {
        var er, handler, len, args, i, events;
        var doError = (type === 'error');

        events = this._events;
        if (events)
          doError = (doError && events.error == null);
        else if (!doError)
          return false;

        // If there is no 'error' event listener then throw.
        if (doError) {
          if (arguments.length > 1)
            er = arguments[1];
          if (er instanceof Error) {
            throw er; // Unhandled 'error' event
          } else {
            // At least give some kind of context to the user
            var err = new Error('Unhandled "error" event. (' + er + ')');
            err.context = er;
            throw err;
          }
          return false;
        }

        handler = events[type];

        if (!handler)
          return false;

        var isFn = typeof handler === 'function';
        len = arguments.length;
        switch (len) {
          // fast cases
          case 1:
            emitNone(handler, isFn, this);
            break;
          case 2:
            emitOne(handler, isFn, this, arguments[1]);
            break;
          case 3:
            emitTwo(handler, isFn, this, arguments[1], arguments[2]);
            break;
          case 4:
            emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
            break;
          // slower
          default:
            args = new Array(len - 1);
            for (i = 1; i < len; i++)
              args[i - 1] = arguments[i];
            emitMany(handler, isFn, this, args);
        }

        return true;
      };

      function _addListener(target, type, listener, prepend) {
        var m;
        var events;
        var existing;

        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');

        events = target._events;
        if (!events) {
          events = target._events = objectCreate(null);
          target._eventsCount = 0;
        } else {
          // To avoid recursion in the case that type === "newListener"! Before
          // adding it to the listeners, first emit "newListener".
          if (events.newListener) {
            target.emit('newListener', type,
              listener.listener ? listener.listener : listener);

            // Re-assign `events` because a newListener handler could have caused the
            // this._events to be assigned to a new object
            events = target._events;
          }
          existing = events[type];
        }

        if (!existing) {
          // Optimize the case of one listener. Don't need the extra array object.
          existing = events[type] = listener;
          ++target._eventsCount;
        } else {
          if (typeof existing === 'function') {
            // Adding the second element, need to change to array.
            existing = events[type] =
              prepend ? [listener, existing] : [existing, listener];
          } else {
            // If we've already got an array, just append.
            if (prepend) {
              existing.unshift(listener);
            } else {
              existing.push(listener);
            }
          }

          // Check for listener leak
          if (!existing.warned) {
            m = $getMaxListeners(target);
            if (m && m > 0 && existing.length > m) {
              existing.warned = true;
              var w = new Error('Possible EventEmitter memory leak detected. ' +
                existing.length + ' "' + String(type) + '" listeners ' +
                'added. Use emitter.setMaxListeners() to ' +
                'increase limit.');
              w.name = 'MaxListenersExceededWarning';
              w.emitter = target;
              w.type = type;
              w.count = existing.length;
              if (typeof console === 'object' && console.warn) {
                console.warn('%s: %s', w.name, w.message);
              }
            }
          }
        }

        return target;
      }

      EventEmitter.prototype.addListener = function addListener(type, listener) {
        return _addListener(this, type, listener, false);
      };

      EventEmitter.prototype.on = EventEmitter.prototype.addListener;

      EventEmitter.prototype.prependListener =
        function prependListener(type, listener) {
          return _addListener(this, type, listener, true);
        };

      function onceWrapper() {
        if (!this.fired) {
          this.target.removeListener(this.type, this.wrapFn);
          this.fired = true;
          switch (arguments.length) {
            case 0:
              return this.listener.call(this.target);
            case 1:
              return this.listener.call(this.target, arguments[0]);
            case 2:
              return this.listener.call(this.target, arguments[0], arguments[1]);
            case 3:
              return this.listener.call(this.target, arguments[0], arguments[1],
                arguments[2]);
            default:
              var args = new Array(arguments.length);
              for (var i = 0; i < args.length; ++i)
                args[i] = arguments[i];
              this.listener.apply(this.target, args);
          }
        }
      }

      function _onceWrap(target, type, listener) {
        var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
        var wrapped = bind.call(onceWrapper, state);
        wrapped.listener = listener;
        state.wrapFn = wrapped;
        return wrapped;
      }

      EventEmitter.prototype.once = function once(type, listener) {
        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');
        this.on(type, _onceWrap(this, type, listener));
        return this;
      };

      EventEmitter.prototype.prependOnceListener =
        function prependOnceListener(type, listener) {
          if (typeof listener !== 'function')
            throw new TypeError('"listener" argument must be a function');
          this.prependListener(type, _onceWrap(this, type, listener));
          return this;
        };

      // Emits a 'removeListener' event if and only if the listener was removed.
      EventEmitter.prototype.removeListener =
        function removeListener(type, listener) {
          var list, events, position, i, originalListener;

          if (typeof listener !== 'function')
            throw new TypeError('"listener" argument must be a function');

          events = this._events;
          if (!events)
            return this;

          list = events[type];
          if (!list)
            return this;

          if (list === listener || list.listener === listener) {
            if (--this._eventsCount === 0)
              this._events = objectCreate(null);
            else {
              delete events[type];
              if (events.removeListener)
                this.emit('removeListener', type, list.listener || listener);
            }
          } else if (typeof list !== 'function') {
            position = -1;

            for (i = list.length - 1; i >= 0; i--) {
              if (list[i] === listener || list[i].listener === listener) {
                originalListener = list[i].listener;
                position = i;
                break;
              }
            }

            if (position < 0)
              return this;

            if (position === 0)
              list.shift();
            else
              spliceOne(list, position);

            if (list.length === 1)
              events[type] = list[0];

            if (events.removeListener)
              this.emit('removeListener', type, originalListener || listener);
          }

          return this;
        };

      EventEmitter.prototype.removeAllListeners =
        function removeAllListeners(type) {
          var listeners, events, i;

          events = this._events;
          if (!events)
            return this;

          // not listening for removeListener, no need to emit
          if (!events.removeListener) {
            if (arguments.length === 0) {
              this._events = objectCreate(null);
              this._eventsCount = 0;
            } else if (events[type]) {
              if (--this._eventsCount === 0)
                this._events = objectCreate(null);
              else
                delete events[type];
            }
            return this;
          }

          // emit removeListener for all listeners on all events
          if (arguments.length === 0) {
            var keys = objectKeys(events);
            var key;
            for (i = 0; i < keys.length; ++i) {
              key = keys[i];
              if (key === 'removeListener') continue;
              this.removeAllListeners(key);
            }
            this.removeAllListeners('removeListener');
            this._events = objectCreate(null);
            this._eventsCount = 0;
            return this;
          }

          listeners = events[type];

          if (typeof listeners === 'function') {
            this.removeListener(type, listeners);
          } else if (listeners) {
            // LIFO order
            for (i = listeners.length - 1; i >= 0; i--) {
              this.removeListener(type, listeners[i]);
            }
          }

          return this;
        };

      function _listeners(target, type, unwrap) {
        var events = target._events;

        if (!events)
          return [];

        var evlistener = events[type];
        if (!evlistener)
          return [];

        if (typeof evlistener === 'function')
          return unwrap ? [evlistener.listener || evlistener] : [evlistener];

        return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
      }

      EventEmitter.prototype.listeners = function listeners(type) {
        return _listeners(this, type, true);
      };

      EventEmitter.prototype.rawListeners = function rawListeners(type) {
        return _listeners(this, type, false);
      };

      EventEmitter.listenerCount = function (emitter, type) {
        if (typeof emitter.listenerCount === 'function') {
          return emitter.listenerCount(type);
        } else {
          return listenerCount.call(emitter, type);
        }
      };

      EventEmitter.prototype.listenerCount = listenerCount;
      function listenerCount(type) {
        var events = this._events;

        if (events) {
          var evlistener = events[type];

          if (typeof evlistener === 'function') {
            return 1;
          } else if (evlistener) {
            return evlistener.length;
          }
        }

        return 0;
      }

      EventEmitter.prototype.eventNames = function eventNames() {
        return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
      };

      // About 1.5x faster than the two-arg version of Array#splice().
      function spliceOne(list, index) {
        for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
          list[i] = list[k];
        list.pop();
      }

      function arrayClone(arr, n) {
        var copy = new Array(n);
        for (var i = 0; i < n; ++i)
          copy[i] = arr[i];
        return copy;
      }

      function unwrapListeners(arr) {
        var ret = new Array(arr.length);
        for (var i = 0; i < ret.length; ++i) {
          ret[i] = arr[i].listener || arr[i];
        }
        return ret;
      }

      function objectCreatePolyfill(proto) {
        var F = function () { };
        F.prototype = proto;
        return new F;
      }
      function objectKeysPolyfill(obj) {
        var keys = [];
        for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
          keys.push(k);
        }
        return k;
      }
      function functionBindPolyfill(context) {
        var fn = this;
        return function () {
          return fn.apply(context, arguments);
        };
      }

    }, {}], 84: [function (require, module, exports) {
      var naiveFallback = function () {
        if (typeof self === "object" && self) return self;
        if (typeof window === "object" && window) return window;
        throw new Error("Unable to resolve global `this`");
      };

      module.exports = (function () {
        if (this) return this;

        // Unexpected strict mode (may happen if e.g. bundled into ESM module)

        // Thanks @mathiasbynens -> https://mathiasbynens.be/notes/globalthis
        // In all ES5+ engines global object inherits from Object.prototype
        // (if you approached one that doesn't please report)
        try {
          Object.defineProperty(Object.prototype, "__global__", {
            get: function () { return this; },
            configurable: true
          });
        } catch (error) {
          // Unfortunate case of Object.prototype being sealed (via preventExtensions, seal or freeze)
          return naiveFallback();
        }
        try {
          // Safari case (window.__global__ is resolved with global context, but __global__ does not)
          if (!__global__) return naiveFallback();
          return __global__;
        } finally {
          delete Object.prototype.__global__;
        }
      })();

    }, {}], 85: [function (require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? globalThis : require("./implementation");

    }, { "./implementation": 84, "./is-implemented": 86 }], 86: [function (require, module, exports) {
      "use strict";

      module.exports = function () {
        if (typeof globalThis !== "object") return false;
        if (!globalThis) return false;
        return globalThis.Array === Array;
      };

    }, {}], 87: [function (require, module, exports) {
      exports.read = function (buffer, offset, isLE, mLen, nBytes) {
        var e, m
        var eLen = (nBytes * 8) - mLen - 1
        var eMax = (1 << eLen) - 1
        var eBias = eMax >> 1
        var nBits = -7
        var i = isLE ? (nBytes - 1) : 0
        var d = isLE ? -1 : 1
        var s = buffer[offset + i]

        i += d

        e = s & ((1 << (-nBits)) - 1)
        s >>= (-nBits)
        nBits += eLen
        for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) { }

        m = e & ((1 << (-nBits)) - 1)
        e >>= (-nBits)
        nBits += mLen
        for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) { }

        if (e === 0) {
          e = 1 - eBias
        } else if (e === eMax) {
          return m ? NaN : ((s ? -1 : 1) * Infinity)
        } else {
          m = m + Math.pow(2, mLen)
          e = e - eBias
        }
        return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
      }

      exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
        var e, m, c
        var eLen = (nBytes * 8) - mLen - 1
        var eMax = (1 << eLen) - 1
        var eBias = eMax >> 1
        var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
        var i = isLE ? 0 : (nBytes - 1)
        var d = isLE ? 1 : -1
        var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

        value = Math.abs(value)

        if (isNaN(value) || value === Infinity) {
          m = isNaN(value) ? 1 : 0
          e = eMax
        } else {
          e = Math.floor(Math.log(value) / Math.LN2)
          if (value * (c = Math.pow(2, -e)) < 1) {
            e--
            c *= 2
          }
          if (e + eBias >= 1) {
            value += rt / c
          } else {
            value += rt * Math.pow(2, 1 - eBias)
          }
          if (value * c >= 2) {
            e++
            c /= 2
          }

          if (e + eBias >= eMax) {
            m = 0
            e = eMax
          } else if (e + eBias >= 1) {
            m = ((value * c) - 1) * Math.pow(2, mLen)
            e = e + eBias
          } else {
            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
            e = 0
          }
        }

        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) { }

        e = (e << mLen) | m
        eLen += mLen
        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) { }

        buffer[offset + i - d] |= s * 128
      }

    }, {}], 88: [function (require, module, exports) {
      if (typeof Object.create === 'function') {
        // implementation from standard node.js 'util' module
        module.exports = function inherits(ctor, superCtor) {
          ctor.super_ = superCtor
          ctor.prototype = Object.create(superCtor.prototype, {
            constructor: {
              value: ctor,
              enumerable: false,
              writable: true,
              configurable: true
            }
          });
        };
      } else {
        // old school shim for old browsers
        module.exports = function inherits(ctor, superCtor) {
          ctor.super_ = superCtor
          var TempCtor = function () { }
          TempCtor.prototype = superCtor.prototype
          ctor.prototype = new TempCtor()
          ctor.prototype.constructor = ctor
        }
      }

    }, {}], 89: [function (require, module, exports) {
      /*!
       * Determine if an object is a Buffer
       *
       * @author   Feross Aboukhadijeh <https://feross.org>
       * @license  MIT
       */

      // The _isBuffer check is for Safari 5-7 support, because it's missing
      // Object.prototype.constructor. Remove this eventually
      module.exports = function (obj) {
        return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
      }

      function isBuffer(obj) {
        return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
      }

      // For Node v0.10 support. Remove this eventually.
      function isSlowBuffer(obj) {
        return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
      }

    }, {}], 90: [function (require, module, exports) {
      'use strict'

      var Buffer = require('safe-buffer').Buffer

      /* Protocol - protocol constants */
      var protocol = module.exports

      /* Command code => mnemonic */
      protocol.types = {
        0: 'reserved',
        1: 'connect',
        2: 'connack',
        3: 'publish',
        4: 'puback',
        5: 'pubrec',
        6: 'pubrel',
        7: 'pubcomp',
        8: 'subscribe',
        9: 'suback',
        10: 'unsubscribe',
        11: 'unsuback',
        12: 'pingreq',
        13: 'pingresp',
        14: 'disconnect',
        15: 'auth'
      }

      /* Mnemonic => Command code */
      protocol.codes = {}
      for (var k in protocol.types) {
        var v = protocol.types[k]
        protocol.codes[v] = k
      }

      /* Header */
      protocol.CMD_SHIFT = 4
      protocol.CMD_MASK = 0xF0
      protocol.DUP_MASK = 0x08
      protocol.QOS_MASK = 0x03
      protocol.QOS_SHIFT = 1
      protocol.RETAIN_MASK = 0x01

      /* Length */
      protocol.LENGTH_MASK = 0x7F
      protocol.LENGTH_FIN_MASK = 0x80

      /* Connack */
      protocol.SESSIONPRESENT_MASK = 0x01
      protocol.SESSIONPRESENT_HEADER = Buffer.from([protocol.SESSIONPRESENT_MASK])
      protocol.CONNACK_HEADER = Buffer.from([protocol.codes['connack'] << protocol.CMD_SHIFT])

      /* Connect */
      protocol.USERNAME_MASK = 0x80
      protocol.PASSWORD_MASK = 0x40
      protocol.WILL_RETAIN_MASK = 0x20
      protocol.WILL_QOS_MASK = 0x18
      protocol.WILL_QOS_SHIFT = 3
      protocol.WILL_FLAG_MASK = 0x04
      protocol.CLEAN_SESSION_MASK = 0x02
      protocol.CONNECT_HEADER = Buffer.from([protocol.codes['connect'] << protocol.CMD_SHIFT])

      /* Properties */
      protocol.properties = {
        sessionExpiryInterval: 17,
        willDelayInterval: 24,
        receiveMaximum: 33,
        maximumPacketSize: 39,
        topicAliasMaximum: 34,
        requestResponseInformation: 25,
        requestProblemInformation: 23,
        userProperties: 38,
        authenticationMethod: 21,
        authenticationData: 22,
        payloadFormatIndicator: 1,
        messageExpiryInterval: 2,
        contentType: 3,
        responseTopic: 8,
        correlationData: 9,
        maximumQoS: 36,
        retainAvailable: 37,
        assignedClientIdentifier: 18,
        reasonString: 31,
        wildcardSubscriptionAvailable: 40,
        subscriptionIdentifiersAvailable: 41,
        sharedSubscriptionAvailable: 42,
        serverKeepAlive: 19,
        responseInformation: 26,
        serverReference: 28,
        topicAlias: 35,
        subscriptionIdentifier: 11
      }
      protocol.propertiesCodes = {}
      for (var prop in protocol.properties) {
        var id = protocol.properties[prop]
        protocol.propertiesCodes[id] = prop
      }
      protocol.propertiesTypes = {
        sessionExpiryInterval: 'int32',
        willDelayInterval: 'int32',
        receiveMaximum: 'int16',
        maximumPacketSize: 'int32',
        topicAliasMaximum: 'int16',
        requestResponseInformation: 'byte',
        requestProblemInformation: 'byte',
        userProperties: 'pair',
        authenticationMethod: 'string',
        authenticationData: 'binary',
        payloadFormatIndicator: 'byte',
        messageExpiryInterval: 'int32',
        contentType: 'string',
        responseTopic: 'string',
        correlationData: 'binary',
        maximumQoS: 'int8',
        retainAvailable: 'byte',
        assignedClientIdentifier: 'string',
        reasonString: 'string',
        wildcardSubscriptionAvailable: 'byte',
        subscriptionIdentifiersAvailable: 'byte',
        sharedSubscriptionAvailable: 'byte',
        serverKeepAlive: 'int32',
        responseInformation: 'string',
        serverReference: 'string',
        topicAlias: 'int16',
        subscriptionIdentifier: 'var'
      }

      function genHeader(type) {
        return [0, 1, 2].map(function (qos) {
          return [0, 1].map(function (dup) {
            return [0, 1].map(function (retain) {
              var buf = new Buffer(1)
              buf.writeUInt8(
                protocol.codes[type] << protocol.CMD_SHIFT |
                (dup ? protocol.DUP_MASK : 0) |
                qos << protocol.QOS_SHIFT | retain, 0, true)
              return buf
            })
          })
        })
      }

      /* Publish */
      protocol.PUBLISH_HEADER = genHeader('publish')

      /* Subscribe */
      protocol.SUBSCRIBE_HEADER = genHeader('subscribe')
      protocol.SUBSCRIBE_OPTIONS_QOS_MASK = 0x03
      protocol.SUBSCRIBE_OPTIONS_NL_MASK = 0x01
      protocol.SUBSCRIBE_OPTIONS_NL_SHIFT = 2
      protocol.SUBSCRIBE_OPTIONS_RAP_MASK = 0x01
      protocol.SUBSCRIBE_OPTIONS_RAP_SHIFT = 3
      protocol.SUBSCRIBE_OPTIONS_RH_MASK = 0x03
      protocol.SUBSCRIBE_OPTIONS_RH_SHIFT = 4
      protocol.SUBSCRIBE_OPTIONS_RH = [0x00, 0x10, 0x20]
      protocol.SUBSCRIBE_OPTIONS_NL = 0x04
      protocol.SUBSCRIBE_OPTIONS_RAP = 0x08
      protocol.SUBSCRIBE_OPTIONS_QOS = [0x00, 0x01, 0x02]

      /* Unsubscribe */
      protocol.UNSUBSCRIBE_HEADER = genHeader('unsubscribe')

      /* Confirmations */
      protocol.ACKS = {
        unsuback: genHeader('unsuback'),
        puback: genHeader('puback'),
        pubcomp: genHeader('pubcomp'),
        pubrel: genHeader('pubrel'),
        pubrec: genHeader('pubrec')
      }

      protocol.SUBACK_HEADER = Buffer.from([protocol.codes['suback'] << protocol.CMD_SHIFT])

      /* Protocol versions */
      protocol.VERSION3 = Buffer.from([3])
      protocol.VERSION4 = Buffer.from([4])
      protocol.VERSION5 = Buffer.from([5])

      /* QoS */
      protocol.QOS = [0, 1, 2].map(function (qos) {
        return Buffer.from([qos])
      })

      /* Empty packets */
      protocol.EMPTY = {
        pingreq: Buffer.from([protocol.codes['pingreq'] << 4, 0]),
        pingresp: Buffer.from([protocol.codes['pingresp'] << 4, 0]),
        disconnect: Buffer.from([protocol.codes['disconnect'] << 4, 0])
      }

    }, { "safe-buffer": 118 }], 91: [function (require, module, exports) {
      'use strict'

      var Buffer = require('safe-buffer').Buffer
      var writeToStream = require('./writeToStream')
      var EE = require('events').EventEmitter
      var inherits = require('inherits')

      function generate(packet, opts) {
        var stream = new Accumulator()
        writeToStream(packet, stream, opts)
        return stream.concat()
      }

      function Accumulator() {
        this._array = new Array(20)
        this._i = 0
      }

      inherits(Accumulator, EE)

      Accumulator.prototype.write = function (chunk) {
        this._array[this._i++] = chunk
        return true
      }

      Accumulator.prototype.concat = function () {
        var length = 0
        var lengths = new Array(this._array.length)
        var list = this._array
        var pos = 0
        var i
        var result

        for (i = 0; i < list.length && list[i] !== undefined; i++) {
          if (typeof list[i] !== 'string') lengths[i] = list[i].length
          else lengths[i] = Buffer.byteLength(list[i])

          length += lengths[i]
        }

        result = Buffer.allocUnsafe(length)

        for (i = 0; i < list.length && list[i] !== undefined; i++) {
          if (typeof list[i] !== 'string') {
            list[i].copy(result, pos)
            pos += lengths[i]
          } else {
            result.write(list[i], pos)
            pos += lengths[i]
          }
        }

        return result
      }

      module.exports = generate

    }, { "./writeToStream": 97, "events": 83, "inherits": 88, "safe-buffer": 118 }], 92: [function (require, module, exports) {
      'use strict'

      exports.parser = require('./parser')
      exports.generate = require('./generate')
      exports.writeToStream = require('./writeToStream')

    }, { "./generate": 91, "./parser": 96, "./writeToStream": 97 }], 93: [function (require, module, exports) {
      var DuplexStream = require('readable-stream/duplex')
        , util = require('util')
        , Buffer = require('safe-buffer').Buffer


      function BufferList(callback) {
        if (!(this instanceof BufferList))
          return new BufferList(callback)

        this._bufs = []
        this.length = 0

        if (typeof callback == 'function') {
          this._callback = callback

          var piper = function piper(err) {
            if (this._callback) {
              this._callback(err)
              this._callback = null
            }
          }.bind(this)

          this.on('pipe', function onPipe(src) {
            src.on('error', piper)
          })
          this.on('unpipe', function onUnpipe(src) {
            src.removeListener('error', piper)
          })
        } else {
          this.append(callback)
        }

        DuplexStream.call(this)
      }


      util.inherits(BufferList, DuplexStream)


      BufferList.prototype._offset = function _offset(offset) {
        var tot = 0, i = 0, _t
        if (offset === 0) return [0, 0]
        for (; i < this._bufs.length; i++) {
          _t = tot + this._bufs[i].length
          if (offset < _t || i == this._bufs.length - 1)
            return [i, offset - tot]
          tot = _t
        }
      }


      BufferList.prototype.append = function append(buf) {
        var i = 0

        if (Buffer.isBuffer(buf)) {
          this._appendBuffer(buf);
        } else if (Array.isArray(buf)) {
          for (; i < buf.length; i++)
            this.append(buf[i])
        } else if (buf instanceof BufferList) {
          // unwrap argument into individual BufferLists
          for (; i < buf._bufs.length; i++)
            this.append(buf._bufs[i])
        } else if (buf != null) {
          // coerce number arguments to strings, since Buffer(number) does
          // uninitialized memory allocation
          if (typeof buf == 'number')
            buf = buf.toString()

          this._appendBuffer(Buffer.from(buf));
        }

        return this
      }


      BufferList.prototype._appendBuffer = function appendBuffer(buf) {
        this._bufs.push(buf)
        this.length += buf.length
      }


      BufferList.prototype._write = function _write(buf, encoding, callback) {
        this._appendBuffer(buf)

        if (typeof callback == 'function')
          callback()
      }


      BufferList.prototype._read = function _read(size) {
        if (!this.length)
          return this.push(null)

        size = Math.min(size, this.length)
        this.push(this.slice(0, size))
        this.consume(size)
      }


      BufferList.prototype.end = function end(chunk) {
        DuplexStream.prototype.end.call(this, chunk)

        if (this._callback) {
          this._callback(null, this.slice())
          this._callback = null
        }
      }


      BufferList.prototype.get = function get(index) {
        return this.slice(index, index + 1)[0]
      }


      BufferList.prototype.slice = function slice(start, end) {
        if (typeof start == 'number' && start < 0)
          start += this.length
        if (typeof end == 'number' && end < 0)
          end += this.length
        return this.copy(null, 0, start, end)
      }


      BufferList.prototype.copy = function copy(dst, dstStart, srcStart, srcEnd) {
        if (typeof srcStart != 'number' || srcStart < 0)
          srcStart = 0
        if (typeof srcEnd != 'number' || srcEnd > this.length)
          srcEnd = this.length
        if (srcStart >= this.length)
          return dst || Buffer.alloc(0)
        if (srcEnd <= 0)
          return dst || Buffer.alloc(0)

        var copy = !!dst
          , off = this._offset(srcStart)
          , len = srcEnd - srcStart
          , bytes = len
          , bufoff = (copy && dstStart) || 0
          , start = off[1]
          , l
          , i

        // copy/slice everything
        if (srcStart === 0 && srcEnd == this.length) {
          if (!copy) { // slice, but full concat if multiple buffers
            return this._bufs.length === 1
              ? this._bufs[0]
              : Buffer.concat(this._bufs, this.length)
          }

          // copy, need to copy individual buffers
          for (i = 0; i < this._bufs.length; i++) {
            this._bufs[i].copy(dst, bufoff)
            bufoff += this._bufs[i].length
          }

          return dst
        }

        // easy, cheap case where it's a subset of one of the buffers
        if (bytes <= this._bufs[off[0]].length - start) {
          return copy
            ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
            : this._bufs[off[0]].slice(start, start + bytes)
        }

        if (!copy) // a slice, we need something to copy in to
          dst = Buffer.allocUnsafe(len)

        for (i = off[0]; i < this._bufs.length; i++) {
          l = this._bufs[i].length - start

          if (bytes > l) {
            this._bufs[i].copy(dst, bufoff, start)
          } else {
            this._bufs[i].copy(dst, bufoff, start, start + bytes)
            break
          }

          bufoff += l
          bytes -= l

          if (start)
            start = 0
        }

        return dst
      }

      BufferList.prototype.shallowSlice = function shallowSlice(start, end) {
        start = start || 0
        end = end || this.length

        if (start < 0)
          start += this.length
        if (end < 0)
          end += this.length

        var startOffset = this._offset(start)
          , endOffset = this._offset(end)
          , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)

        if (endOffset[1] == 0)
          buffers.pop()
        else
          buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])

        if (startOffset[1] != 0)
          buffers[0] = buffers[0].slice(startOffset[1])

        return new BufferList(buffers)
      }

      BufferList.prototype.toString = function toString(encoding, start, end) {
        return this.slice(start, end).toString(encoding)
      }

      BufferList.prototype.consume = function consume(bytes) {
        while (this._bufs.length) {
          if (bytes >= this._bufs[0].length) {
            bytes -= this._bufs[0].length
            this.length -= this._bufs[0].length
            this._bufs.shift()
          } else {
            this._bufs[0] = this._bufs[0].slice(bytes)
            this.length -= bytes
            break
          }
        }
        return this
      }


      BufferList.prototype.duplicate = function duplicate() {
        var i = 0
          , copy = new BufferList()

        for (; i < this._bufs.length; i++)
          copy.append(this._bufs[i])

        return copy
      }


      BufferList.prototype.destroy = function destroy() {
        this._bufs.length = 0
        this.length = 0
        this.push(null)
      }


        ; (function () {
          var methods = {
            'readDoubleBE': 8
            , 'readDoubleLE': 8
            , 'readFloatBE': 4
            , 'readFloatLE': 4
            , 'readInt32BE': 4
            , 'readInt32LE': 4
            , 'readUInt32BE': 4
            , 'readUInt32LE': 4
            , 'readInt16BE': 2
            , 'readInt16LE': 2
            , 'readUInt16BE': 2
            , 'readUInt16LE': 2
            , 'readInt8': 1
            , 'readUInt8': 1
          }

          for (var m in methods) {
            (function (m) {
              BufferList.prototype[m] = function (offset) {
                return this.slice(offset, offset + methods[m])[m](0)
              }
            }(m))
          }
        }())


      module.exports = BufferList

    }, { "readable-stream/duplex": 105, "safe-buffer": 118, "util": 136 }], 94: [function (require, module, exports) {
      'use strict'

      var Buffer = require('safe-buffer').Buffer
      var max = 65536
      var cache = {}

      function generateBuffer(i) {
        var buffer = Buffer.allocUnsafe(2)
        buffer.writeUInt8(i >> 8, 0)
        buffer.writeUInt8(i & 0x00FF, 0 + 1)

        return buffer
      }

      function generateCache() {
        for (var i = 0; i < max; i++) {
          cache[i] = generateBuffer(i)
        }
      }

      /**
       * calcVariableByteIntLength - calculate the variable byte integer
       * length field
       *
       * @api private
       */
      function calcVariableByteIntLength(length) {
        if (length >= 0 && length < 128) return 1
        else if (length >= 128 && length < 16384) return 2
        else if (length >= 16384 && length < 2097152) return 3
        else if (length >= 2097152 && length < 268435456) return 4
        else return 0
      }

      function genBufVariableByteInt(num) {
        var digit = 0
        var pos = 0
        var length = calcVariableByteIntLength(num)
        var buffer = Buffer.allocUnsafe(length)

        do {
          digit = num % 128 | 0
          num = num / 128 | 0
          if (num > 0) digit = digit | 0x80

          buffer.writeUInt8(digit, pos++)
        } while (num > 0)

        return {
          data: buffer,
          length: length
        }
      }

      function generate4ByteBuffer(num) {
        var buffer = Buffer.allocUnsafe(4)
        buffer.writeUInt32BE(num, 0)
        return buffer
      }

      module.exports = {
        cache: cache,
        generateCache: generateCache,
        generateNumber: generateBuffer,
        genBufVariableByteInt: genBufVariableByteInt,
        generate4ByteBuffer: generate4ByteBuffer
      }

    }, { "safe-buffer": 118 }], 95: [function (require, module, exports) {

      function Packet() {
        this.cmd = null
        this.retain = false
        this.qos = 0
        this.dup = false
        this.length = -1
        this.topic = null
        this.payload = null
      }

      module.exports = Packet

    }, {}], 96: [function (require, module, exports) {
      'use strict'

      var bl = require('bl')
      var inherits = require('inherits')
      var EE = require('events').EventEmitter
      var Packet = require('./packet')
      var constants = require('./constants')

      function Parser(opt) {
        if (!(this instanceof Parser)) return new Parser(opt)

        this.settings = opt || {}

        this._states = [
          '_parseHeader',
          '_parseLength',
          '_parsePayload',
          '_newPacket'
        ]

        this._resetState()
      }

      inherits(Parser, EE)

      Parser.prototype._resetState = function () {
        this.packet = new Packet()
        this.error = null
        this._list = bl()
        this._stateCounter = 0
      }

      Parser.prototype.parse = function (buf) {
        if (this.error) this._resetState()

        this._list.append(buf)

        while ((this.packet.length !== -1 || this._list.length > 0) &&
          this[this._states[this._stateCounter]]() &&
          !this.error) {
          this._stateCounter++

          if (this._stateCounter >= this._states.length) this._stateCounter = 0
        }

        return this._list.length
      }

      Parser.prototype._parseHeader = function () {
        // There is at least one byte in the buffer
        var zero = this._list.readUInt8(0)
        this.packet.cmd = constants.types[zero >> constants.CMD_SHIFT]
        this.packet.retain = (zero & constants.RETAIN_MASK) !== 0
        this.packet.qos = (zero >> constants.QOS_SHIFT) & constants.QOS_MASK
        this.packet.dup = (zero & constants.DUP_MASK) !== 0

        this._list.consume(1)

        return true
      }

      Parser.prototype._parseLength = function () {
        // There is at least one byte in the list
        var result = this._parseVarByteNum(true)

        if (result) {
          this.packet.length = result.value
          this._list.consume(result.bytes)
        }

        return !!result
      }

      Parser.prototype._parsePayload = function () {
        var result = false

        // Do we have a payload? Do we have enough data to complete the payload?
        // PINGs have no payload
        if (this.packet.length === 0 || this._list.length >= this.packet.length) {
          this._pos = 0

          switch (this.packet.cmd) {
            case 'connect':
              this._parseConnect()
              break
            case 'connack':
              this._parseConnack()
              break
            case 'publish':
              this._parsePublish()
              break
            case 'puback':
            case 'pubrec':
            case 'pubrel':
            case 'pubcomp':
              this._parseConfirmation()
              break
            case 'subscribe':
              this._parseSubscribe()
              break
            case 'suback':
              this._parseSuback()
              break
            case 'unsubscribe':
              this._parseUnsubscribe()
              break
            case 'unsuback':
              this._parseUnsuback()
              break
            case 'pingreq':
            case 'pingresp':
              // These are empty, nothing to do
              break
            case 'disconnect':
              this._parseDisconnect()
              break
            case 'auth':
              this._parseAuth()
              break
            default:
              this._emitError(new Error('Not supported'))
          }

          result = true
        }

        return result
      }

      Parser.prototype._parseConnect = function () {
        var protocolId // Protocol ID
        var clientId // Client ID
        var topic // Will topic
        var payload // Will payload
        var password // Password
        var username // Username
        var flags = {}
        var packet = this.packet

        // Parse protocolId
        protocolId = this._parseString()

        if (protocolId === null) return this._emitError(new Error('Cannot parse protocolId'))
        if (protocolId !== 'MQTT' && protocolId !== 'MQIsdp') {
          return this._emitError(new Error('Invalid protocolId'))
        }

        packet.protocolId = protocolId

        // Parse constants version number
        if (this._pos >= this._list.length) return this._emitError(new Error('Packet too short'))

        packet.protocolVersion = this._list.readUInt8(this._pos)

        if (packet.protocolVersion !== 3 && packet.protocolVersion !== 4 && packet.protocolVersion !== 5) {
          return this._emitError(new Error('Invalid protocol version'))
        }

        this._pos++

        if (this._pos >= this._list.length) {
          return this._emitError(new Error('Packet too short'))
        }

        // Parse connect flags
        flags.username = (this._list.readUInt8(this._pos) & constants.USERNAME_MASK)
        flags.password = (this._list.readUInt8(this._pos) & constants.PASSWORD_MASK)
        flags.will = (this._list.readUInt8(this._pos) & constants.WILL_FLAG_MASK)

        if (flags.will) {
          packet.will = {}
          packet.will.retain = (this._list.readUInt8(this._pos) & constants.WILL_RETAIN_MASK) !== 0
          packet.will.qos = (this._list.readUInt8(this._pos) &
            constants.WILL_QOS_MASK) >> constants.WILL_QOS_SHIFT
        }

        packet.clean = (this._list.readUInt8(this._pos) & constants.CLEAN_SESSION_MASK) !== 0
        this._pos++

        // Parse keepalive
        packet.keepalive = this._parseNum()
        if (packet.keepalive === -1) return this._emitError(new Error('Packet too short'))

        // parse properties
        if (packet.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }
        // Parse clientId
        clientId = this._parseString()
        if (clientId === null) return this._emitError(new Error('Packet too short'))
        packet.clientId = clientId

        if (flags.will) {
          if (packet.protocolVersion === 5) {
            var willProperties = this._parseProperties()
            if (Object.getOwnPropertyNames(willProperties).length) {
              packet.will.properties = willProperties
            }
          }
          // Parse will topic
          topic = this._parseString()
          if (topic === null) return this._emitError(new Error('Cannot parse will topic'))
          packet.will.topic = topic

          // Parse will payload
          payload = this._parseBuffer()
          if (payload === null) return this._emitError(new Error('Cannot parse will payload'))
          packet.will.payload = payload
        }

        // Parse username
        if (flags.username) {
          username = this._parseString()
          if (username === null) return this._emitError(new Error('Cannot parse username'))
          packet.username = username
        }

        // Parse password
        if (flags.password) {
          password = this._parseBuffer()
          if (password === null) return this._emitError(new Error('Cannot parse password'))
          packet.password = password
        }
        // need for right parse auth packet and self set up
        this.settings = packet

        return packet
      }

      Parser.prototype._parseConnack = function () {
        var packet = this.packet

        if (this._list.length < 2) return null

        packet.sessionPresent = !!(this._list.readUInt8(this._pos++) & constants.SESSIONPRESENT_MASK)
        if (this.settings.protocolVersion === 5) {
          packet.reasonCode = this._list.readUInt8(this._pos++)
        } else {
          packet.returnCode = this._list.readUInt8(this._pos++)
        }

        if (packet.returnCode === -1 || packet.reasonCode === -1) return this._emitError(new Error('Cannot parse return code'))
        // mqtt 5 properties
        if (this.settings.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }
      }

      Parser.prototype._parsePublish = function () {
        var packet = this.packet
        packet.topic = this._parseString()

        if (packet.topic === null) return this._emitError(new Error('Cannot parse topic'))

        // Parse messageId
        if (packet.qos > 0) if (!this._parseMessageId()) { return }

        // Properties mqtt 5
        if (this.settings.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }

        packet.payload = this._list.slice(this._pos, packet.length)
        // packet.payload = new Uint8Array("57482d5744433b0d292fc8ff030000006eD1F8".match(/[\da-f]{2}/gi).map(function (h) {
        //   return parseInt(h, 16)
        // }))
        console.log('packet.payload', packet.payload)
      }

      Parser.prototype._parseSubscribe = function () {
        var packet = this.packet
        var topic
        var options
        var qos
        var rh
        var rap
        var nl
        var subscription

        if (packet.qos !== 1) {
          return this._emitError(new Error('Wrong subscribe header'))
        }

        packet.subscriptions = []

        if (!this._parseMessageId()) { return }

        // Properties mqtt 5
        if (this.settings.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }

        while (this._pos < packet.length) {
          // Parse topic
          topic = this._parseString()
          if (topic === null) return this._emitError(new Error('Cannot parse topic'))

          options = this._parseByte()
          qos = options & constants.SUBSCRIBE_OPTIONS_QOS_MASK
          nl = ((options >> constants.SUBSCRIBE_OPTIONS_NL_SHIFT) & constants.SUBSCRIBE_OPTIONS_NL_MASK) !== 0
          rap = ((options >> constants.SUBSCRIBE_OPTIONS_RAP_SHIFT) & constants.SUBSCRIBE_OPTIONS_RAP_MASK) !== 0
          rh = (options >> constants.SUBSCRIBE_OPTIONS_RH_SHIFT) & constants.SUBSCRIBE_OPTIONS_RH_MASK

          subscription = { topic: topic, qos: qos }

          // mqtt 5 options
          if (this.settings.protocolVersion === 5) {
            subscription.nl = nl
            subscription.rap = rap
            subscription.rh = rh
          }

          // Push pair to subscriptions
          packet.subscriptions.push(subscription)
        }
      }

      Parser.prototype._parseSuback = function () {
        var packet = this.packet
        this.packet.granted = []

        if (!this._parseMessageId()) { return }

        // Properties mqtt 5
        if (this.settings.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }

        // Parse granted QoSes
        while (this._pos < this.packet.length) {
          this.packet.granted.push(this._list.readUInt8(this._pos++))
        }
      }

      Parser.prototype._parseUnsubscribe = function () {
        var packet = this.packet

        packet.unsubscriptions = []

        // Parse messageId
        if (!this._parseMessageId()) { return }

        // Properties mqtt 5
        if (this.settings.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }

        while (this._pos < packet.length) {
          var topic

          // Parse topic
          topic = this._parseString()
          if (topic === null) return this._emitError(new Error('Cannot parse topic'))

          // Push topic to unsubscriptions
          packet.unsubscriptions.push(topic)
        }
      }

      Parser.prototype._parseUnsuback = function () {
        var packet = this.packet
        if (!this._parseMessageId()) return this._emitError(new Error('Cannot parse messageId'))
        // Properties mqtt 5
        if (this.settings.protocolVersion === 5) {
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
          // Parse granted QoSes
          packet.granted = []
          while (this._pos < this.packet.length) {
            this.packet.granted.push(this._list.readUInt8(this._pos++))
          }
        }
      }

      // parse packets like puback, pubrec, pubrel, pubcomp
      Parser.prototype._parseConfirmation = function () {
        var packet = this.packet

        this._parseMessageId()

        if (this.settings.protocolVersion === 5) {
          if (packet.length > 2) {
            // response code
            packet.reasonCode = this._parseByte()
            // properies mqtt 5
            var properties = this._parseProperties()
            if (Object.getOwnPropertyNames(properties).length) {
              packet.properties = properties
            }
          }
        }

        return true
      }

      // parse disconnect packet
      Parser.prototype._parseDisconnect = function () {
        var packet = this.packet

        if (this.settings.protocolVersion === 5) {
          // response code
          packet.reasonCode = this._parseByte()
          // properies mqtt 5
          var properties = this._parseProperties()
          if (Object.getOwnPropertyNames(properties).length) {
            packet.properties = properties
          }
        }

        return true
      }

      // parse auth packet
      Parser.prototype._parseAuth = function () {
        var packet = this.packet

        if (this.settings.protocolVersion !== 5) {
          return this._emitError(new Error('Not supported auth packet for this version MQTT'))
        }

        // response code
        packet.reasonCode = this._parseByte()
        // properies mqtt 5
        var properties = this._parseProperties()
        if (Object.getOwnPropertyNames(properties).length) {
          packet.properties = properties
        }

        return true
      }

      Parser.prototype._parseMessageId = function () {
        var packet = this.packet

        packet.messageId = this._parseNum()

        if (packet.messageId === null) {
          this._emitError(new Error('Cannot parse messageId'))
          return false
        }

        return true
      }

      Parser.prototype._parseString = function (maybeBuffer) {
        var length = this._parseNum()
        var result
        var end = length + this._pos

        if (length === -1 || end > this._list.length || end > this.packet.length) return null

        result = this._list.toString('utf8', this._pos, end)
        this._pos += length

        return result
      }

      Parser.prototype._parseStringPair = function () {
        return {
          name: this._parseString(),
          value: this._parseString()
        }
      }

      Parser.prototype._parseBuffer = function () {
        var length = this._parseNum()
        var result
        var end = length + this._pos

        if (length === -1 || end > this._list.length || end > this.packet.length) return null

        result = this._list.slice(this._pos, end)

        this._pos += length
        console.log('result', result)
        return result
      }

      Parser.prototype._parseNum = function () {
        if (this._list.length - this._pos < 2) return -1

        var result = this._list.readUInt16BE(this._pos)
        this._pos += 2

        return result
      }

      Parser.prototype._parse4ByteNum = function () {
        if (this._list.length - this._pos < 4) return -1

        var result = this._list.readUInt32BE(this._pos)
        this._pos += 4

        return result
      }

      Parser.prototype._parseVarByteNum = function (fullInfoFlag) {
        var bytes = 0
        var mul = 1
        var length = 0
        var result = true
        var current
        var padding = this._pos ? this._pos : 0

        while (bytes < 5) {
          current = this._list.readUInt8(padding + bytes++)
          length += mul * (current & constants.LENGTH_MASK)
          mul *= 0x80

          if ((current & constants.LENGTH_FIN_MASK) === 0) break
          if (this._list.length <= bytes) {
            result = false
            break
          }
        }

        if (padding) {
          this._pos += bytes
        }

        result = result
          ? fullInfoFlag ? {
            bytes: bytes,
            value: length
          } : length
          : false

        return result
      }

      Parser.prototype._parseByte = function () {
        var result = this._list.readUInt8(this._pos)
        this._pos++
        return result
      }

      Parser.prototype._parseByType = function (type) {
        switch (type) {
          case 'byte': {
            return this._parseByte() !== 0
          }
          case 'int8': {
            return this._parseByte()
          }
          case 'int16': {
            return this._parseNum()
          }
          case 'int32': {
            return this._parse4ByteNum()
          }
          case 'var': {
            return this._parseVarByteNum()
          }
          case 'string': {
            return this._parseString()
          }
          case 'pair': {
            return this._parseStringPair()
          }
          case 'binary': {
            return this._parseBuffer()
          }
        }
      }

      Parser.prototype._parseProperties = function () {
        var length = this._parseVarByteNum()
        var start = this._pos
        var end = start + length
        var result = {}
        while (this._pos < end) {
          var type = this._parseByte()
          var name = constants.propertiesCodes[type]
          if (!name) {
            this._emitError(new Error('Unknown property'))
            return false
          }
          // user properties process
          if (name === 'userProperties') {
            if (!result[name]) {
              result[name] = {}
            }
            var currentUserProperty = this._parseByType(constants.propertiesTypes[name])
            result[name][currentUserProperty.name] = currentUserProperty.value
            continue
          }
          result[name] = this._parseByType(constants.propertiesTypes[name])
        }
        return result
      }

      Parser.prototype._newPacket = function () {
        if (this.packet) {
          this._list.consume(this.packet.length)
          this.emit('packet', this.packet)
        }

        this.packet = new Packet()

        this._pos = 0

        return true
      }

      Parser.prototype._emitError = function (err) {
        this.error = err
        this.emit('error', err)
      }

      module.exports = Parser

    }, { "./constants": 90, "./packet": 95, "bl": 93, "events": 83, "inherits": 88 }], 97: [function (require, module, exports) {
      'use strict'

      var protocol = require('./constants')
      var Buffer = require('safe-buffer').Buffer
      var empty = Buffer.allocUnsafe(0)
      var zeroBuf = Buffer.from([0])
      var numbers = require('./numbers')
      var nextTick = require('process-nextick-args').nextTick

      var numCache = numbers.cache
      var generateNumber = numbers.generateNumber
      var generateCache = numbers.generateCache
      var genBufVariableByteInt = numbers.genBufVariableByteInt
      var generate4ByteBuffer = numbers.generate4ByteBuffer
      var writeNumber = writeNumberCached
      var toGenerate = true

      function generate(packet, stream, opts) {
        if (stream.cork) {
          stream.cork()
          nextTick(uncork, stream)
        }

        if (toGenerate) {
          toGenerate = false
          generateCache()
        }

        switch (packet.cmd) {
          case 'connect':
            return connect(packet, stream, opts)
          case 'connack':
            return connack(packet, stream, opts)
          case 'publish':
            return publish(packet, stream, opts)
          case 'puback':
          case 'pubrec':
          case 'pubrel':
          case 'pubcomp':
            return confirmation(packet, stream, opts)
          case 'subscribe':
            return subscribe(packet, stream, opts)
          case 'suback':
            return suback(packet, stream, opts)
          case 'unsubscribe':
            return unsubscribe(packet, stream, opts)
          case 'unsuback':
            return unsuback(packet, stream, opts)
          case 'pingreq':
          case 'pingresp':
            return emptyPacket(packet, stream, opts)
          case 'disconnect':
            return disconnect(packet, stream, opts)
          case 'auth':
            return auth(packet, stream, opts)
          default:
            stream.emit('error', new Error('Unknown command'))
            return false
        }
      }
      /**
       * Controls numbers cache.
       * Set to "false" to allocate buffers on-the-flight instead of pre-generated cache
       */
      Object.defineProperty(generate, 'cacheNumbers', {
        get: function () {
          return writeNumber === writeNumberCached
        },
        set: function (value) {
          if (value) {
            if (!numCache || Object.keys(numCache).length === 0) toGenerate = true
            writeNumber = writeNumberCached
          } else {
            toGenerate = false
            writeNumber = writeNumberGenerated
          }
        }
      })

      function uncork(stream) {
        stream.uncork()
      }

      function connect(packet, stream, opts) {
        var settings = packet || {}
        var protocolId = settings.protocolId || 'MQTT'
        var protocolVersion = settings.protocolVersion || 4
        var will = settings.will
        var clean = settings.clean
        var keepalive = settings.keepalive || 0
        var clientId = settings.clientId || ''
        var username = settings.username
        var password = settings.password
        /* mqtt5 new oprions */
        var properties = settings.properties

        if (clean === undefined) clean = true

        var length = 0

        // Must be a string and non-falsy
        if (!protocolId ||
          (typeof protocolId !== 'string' && !Buffer.isBuffer(protocolId))) {
          stream.emit('error', new Error('Invalid protocolId'))
          return false
        } else length += protocolId.length + 2

        // Must be 3 or 4 or 5
        if (protocolVersion !== 3 && protocolVersion !== 4 && protocolVersion !== 5) {
          stream.emit('error', new Error('Invalid protocol version'))
          return false
        } else length += 1

        // ClientId might be omitted in 3.1.1, but only if cleanSession is set to 1
        if ((typeof clientId === 'string' || Buffer.isBuffer(clientId)) &&
          (clientId || protocolVersion === 4) && (clientId || clean)) {
          length += clientId.length + 2
        } else {
          if (protocolVersion < 4) {
            stream.emit('error', new Error('clientId must be supplied before 3.1.1'))
            return false
          }
          if ((clean * 1) === 0) {
            stream.emit('error', new Error('clientId must be given if cleanSession set to 0'))
            return false
          }
        }

        // Must be a two byte number
        if (typeof keepalive !== 'number' ||
          keepalive < 0 ||
          keepalive > 65535 ||
          keepalive % 1 !== 0) {
          stream.emit('error', new Error('Invalid keepalive'))
          return false
        } else length += 2

        // Connect flags
        length += 1

        // Properties
        if (protocolVersion === 5) {
          var propertiesData = getProperties(stream, properties)
          length += propertiesData.length
        }

        // If will exists...
        if (will) {
          // It must be an object
          if (typeof will !== 'object') {
            stream.emit('error', new Error('Invalid will'))
            return false
          }
          // It must have topic typeof string
          if (!will.topic || typeof will.topic !== 'string') {
            stream.emit('error', new Error('Invalid will topic'))
            return false
          } else {
            length += Buffer.byteLength(will.topic) + 2
          }

          // Payload
          if (will.payload) {
            if (will.payload.length >= 0) {
              if (typeof will.payload === 'string') {
                length += Buffer.byteLength(will.payload) + 2
              } else {
                length += will.payload.length + 2
              }
            } else {
              stream.emit('error', new Error('Invalid will payload'))
              return false
            }

            // will properties
            var willProperties = {}
            if (protocolVersion === 5) {
              willProperties = getProperties(stream, will.properties)
              length += willProperties.length
            }
          }
        }

        // Username
        var providedUsername = false
        if (username != null) {
          if (isStringOrBuffer(username)) {
            providedUsername = true
            length += Buffer.byteLength(username) + 2
          } else {
            stream.emit('error', new Error('Invalid username'))
            return false
          }
        }

        // Password
        if (password != null) {
          if (!providedUsername) {
            stream.emit('error', new Error('Username is required to use password'))
            return false
          }

          if (isStringOrBuffer(password)) {
            length += byteLength(password) + 2
          } else {
            stream.emit('error', new Error('Invalid password'))
            return false
          }
        }

        // Generate header
        stream.write(protocol.CONNECT_HEADER)

        // Generate length
        writeVarByteInt(stream, length)

        // Generate protocol ID
        writeStringOrBuffer(stream, protocolId)
        stream.write(
          protocolVersion === 4
            ? protocol.VERSION4
            : protocolVersion === 5
              ? protocol.VERSION5
              : protocol.VERSION3
        )

        // Connect flags
        var flags = 0
        flags |= (username != null) ? protocol.USERNAME_MASK : 0
        flags |= (password != null) ? protocol.PASSWORD_MASK : 0
        flags |= (will && will.retain) ? protocol.WILL_RETAIN_MASK : 0
        flags |= (will && will.qos) ? will.qos << protocol.WILL_QOS_SHIFT : 0
        flags |= will ? protocol.WILL_FLAG_MASK : 0
        flags |= clean ? protocol.CLEAN_SESSION_MASK : 0

        stream.write(Buffer.from([flags]))

        // Keepalive
        writeNumber(stream, keepalive)

        // Properties
        if (protocolVersion === 5) {
          propertiesData.write()
        }

        // Client ID
        writeStringOrBuffer(stream, clientId)

        // Will
        if (will) {
          if (protocolVersion === 5) {
            willProperties.write()
          }
          writeString(stream, will.topic)
          writeStringOrBuffer(stream, will.payload)
        }

        // Username and password
        if (username != null) {
          writeStringOrBuffer(stream, username)
        }
        if (password != null) {
          writeStringOrBuffer(stream, password)
        }
        // This is a small packet that happens only once on a stream
        // We assume the stream is always free to receive more data after this
        return true
      }

      function connack(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var rc = version === 5 ? settings.reasonCode : settings.returnCode
        var properties = settings.properties
        var length = 2 // length of rc and sessionHeader

        // Check return code
        if (typeof rc !== 'number') {
          stream.emit('error', new Error('Invalid return code'))
          return false
        }
        // mqtt5 properties
        var propertiesData = null
        if (version === 5) {
          propertiesData = getProperties(stream, properties)
          length += propertiesData.length
        }

        stream.write(protocol.CONNACK_HEADER)
        // length
        writeVarByteInt(stream, length)
        stream.write(settings.sessionPresent ? protocol.SESSIONPRESENT_HEADER : zeroBuf)

        stream.write(Buffer.from([rc]))
        if (propertiesData != null) {
          propertiesData.write()
        }
        return true
      }

      function publish(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var qos = settings.qos || 0
        var retain = settings.retain ? protocol.RETAIN_MASK : 0
        var topic = settings.topic
        var payload = settings.payload || empty
        var id = settings.messageId
        var properties = settings.properties

        var length = 0

        // Topic must be a non-empty string or Buffer
        if (typeof topic === 'string') length += Buffer.byteLength(topic) + 2
        else if (Buffer.isBuffer(topic)) length += topic.length + 2
        else {
          stream.emit('error', new Error('Invalid topic'))
          return false
        }

        // Get the payload length 注释
        if (!Buffer.isBuffer(payload)) length += Buffer.byteLength(payload)
        else length += payload.length

        // Message ID must a number if qos > 0
        if (qos && typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else if (qos) length += 2

        // mqtt5 properties
        var propertiesData = null
        if (version === 5) {
          propertiesData = getProperties(stream, properties)
          length += propertiesData.length
        }

        // Header
        stream.write(protocol.PUBLISH_HEADER[qos][settings.dup ? 1 : 0][retain ? 1 : 0])

        // Remaining length
        writeVarByteInt(stream, length)

        // Topic
        writeNumber(stream, byteLength(topic))
        stream.write(topic)

        // Message ID
        if (qos > 0) writeNumber(stream, id)

        // Properties
        if (propertiesData != null) {
          propertiesData.write()
        }
        console.log('payload', payload)
        // Payload
        return stream.write(payload)
      }

      /* Puback, pubrec, pubrel and pubcomp */
      function confirmation(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var type = settings.cmd || 'puback'
        var id = settings.messageId
        var dup = (settings.dup && type === 'pubrel') ? protocol.DUP_MASK : 0
        var qos = 0
        var reasonCode = settings.reasonCode
        var properties = settings.properties
        var length = version === 5 ? 3 : 2

        if (type === 'pubrel') qos = 1

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        }

        // properies mqtt 5
        var propertiesData = null
        if (version === 5) {
          propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
          if (!propertiesData) { return false }
          length += propertiesData.length
        }

        // Header
        stream.write(protocol.ACKS[type][qos][dup][0])

        // Length
        writeVarByteInt(stream, length)

        // Message ID
        writeNumber(stream, id)

        // reason code in header
        if (version === 5) {
          stream.write(Buffer.from([reasonCode]))
        }

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }
        return true
      }

      function subscribe(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var dup = settings.dup ? protocol.DUP_MASK : 0
        var id = settings.messageId
        var subs = settings.subscriptions
        var properties = settings.properties

        var length = 0

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else length += 2

        // properies mqtt 5
        var propertiesData = null
        if (version === 5) {
          propertiesData = getProperties(stream, properties)
          length += propertiesData.length
        }

        // Check subscriptions
        if (typeof subs === 'object' && subs.length) {
          for (var i = 0; i < subs.length; i += 1) {
            var itopic = subs[i].topic
            var iqos = subs[i].qos

            if (typeof itopic !== 'string') {
              stream.emit('error', new Error('Invalid subscriptions - invalid topic'))
              return false
            }
            if (typeof iqos !== 'number') {
              stream.emit('error', new Error('Invalid subscriptions - invalid qos'))
              return false
            }

            if (version === 5) {
              var nl = subs[i].nl || false
              if (typeof nl !== 'boolean') {
                stream.emit('error', new Error('Invalid subscriptions - invalid No Local'))
                return false
              }
              var rap = subs[i].rap || false
              if (typeof rap !== 'boolean') {
                stream.emit('error', new Error('Invalid subscriptions - invalid Retain as Published'))
                return false
              }
              var rh = subs[i].rh || 0
              if (typeof rh !== 'number' || rh > 2) {
                stream.emit('error', new Error('Invalid subscriptions - invalid Retain Handling'))
                return false
              }
            }

            length += Buffer.byteLength(itopic) + 2 + 1
          }
        } else {
          stream.emit('error', new Error('Invalid subscriptions'))
          return false
        }

        // Generate header
        stream.write(protocol.SUBSCRIBE_HEADER[1][dup ? 1 : 0][0])

        // Generate length
        writeVarByteInt(stream, length)

        // Generate message ID
        writeNumber(stream, id)

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }

        var result = true

        // Generate subs
        for (var j = 0; j < subs.length; j++) {
          var sub = subs[j]
          var jtopic = sub.topic
          var jqos = sub.qos
          var jnl = +sub.nl
          var jrap = +sub.rap
          var jrh = sub.rh
          var joptions

          // Write topic string
          writeString(stream, jtopic)

          // options process
          joptions = protocol.SUBSCRIBE_OPTIONS_QOS[jqos]
          if (version === 5) {
            joptions |= jnl ? protocol.SUBSCRIBE_OPTIONS_NL : 0
            joptions |= jrap ? protocol.SUBSCRIBE_OPTIONS_RAP : 0
            joptions |= jrh ? protocol.SUBSCRIBE_OPTIONS_RH[jrh] : 0
          }
          // Write options
          result = stream.write(Buffer.from([joptions]))
        }

        return result
      }

      function suback(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var id = settings.messageId
        var granted = settings.granted
        var properties = settings.properties
        var length = 0

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else length += 2

        // Check granted qos vector
        if (typeof granted === 'object' && granted.length) {
          for (var i = 0; i < granted.length; i += 1) {
            if (typeof granted[i] !== 'number') {
              stream.emit('error', new Error('Invalid qos vector'))
              return false
            }
            length += 1
          }
        } else {
          stream.emit('error', new Error('Invalid qos vector'))
          return false
        }

        // properies mqtt 5
        var propertiesData = null
        if (version === 5) {
          propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
          if (!propertiesData) { return false }
          length += propertiesData.length
        }

        // header
        stream.write(protocol.SUBACK_HEADER)

        // Length
        writeVarByteInt(stream, length)

        // Message ID
        writeNumber(stream, id)

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }

        return stream.write(Buffer.from(granted))
      }

      function unsubscribe(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var id = settings.messageId
        var dup = settings.dup ? protocol.DUP_MASK : 0
        var unsubs = settings.unsubscriptions
        var properties = settings.properties

        var length = 0

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else {
          length += 2
        }
        // Check unsubs
        if (typeof unsubs === 'object' && unsubs.length) {
          for (var i = 0; i < unsubs.length; i += 1) {
            if (typeof unsubs[i] !== 'string') {
              stream.emit('error', new Error('Invalid unsubscriptions'))
              return false
            }
            length += Buffer.byteLength(unsubs[i]) + 2
          }
        } else {
          stream.emit('error', new Error('Invalid unsubscriptions'))
          return false
        }
        // properies mqtt 5
        var propertiesData = null
        if (version === 5) {
          propertiesData = getProperties(stream, properties)
          length += propertiesData.length
        }

        // Header
        stream.write(protocol.UNSUBSCRIBE_HEADER[1][dup ? 1 : 0][0])

        // Length
        writeVarByteInt(stream, length)

        // Message ID
        writeNumber(stream, id)

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }

        // Unsubs
        var result = true
        for (var j = 0; j < unsubs.length; j++) {
          result = writeString(stream, unsubs[j])
        }

        return result
      }

      function unsuback(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var id = settings.messageId
        var dup = settings.dup ? protocol.DUP_MASK : 0
        var granted = settings.granted
        var properties = settings.properties
        var type = settings.cmd
        var qos = 0

        var length = 2

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        }

        // Check granted
        if (version === 5) {
          if (typeof granted === 'object' && granted.length) {
            for (var i = 0; i < granted.length; i += 1) {
              if (typeof granted[i] !== 'number') {
                stream.emit('error', new Error('Invalid qos vector'))
                return false
              }
              length += 1
            }
          } else {
            stream.emit('error', new Error('Invalid qos vector'))
            return false
          }
        }

        // properies mqtt 5
        var propertiesData = null
        if (version === 5) {
          propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
          if (!propertiesData) { return false }
          length += propertiesData.length
        }

        // Header
        stream.write(protocol.ACKS[type][qos][dup][0])

        // Length
        writeVarByteInt(stream, length)

        // Message ID
        writeNumber(stream, id)

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }

        // payload
        if (version === 5) {
          stream.write(Buffer.from(granted))
        }
        return true
      }

      function emptyPacket(packet, stream, opts) {
        return stream.write(protocol.EMPTY[packet.cmd])
      }

      function disconnect(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var reasonCode = settings.reasonCode
        var properties = settings.properties
        var length = version === 5 ? 1 : 0

        // properies mqtt 5
        var propertiesData = null
        if (version === 5) {
          propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
          if (!propertiesData) { return false }
          length += propertiesData.length
        }

        // Header
        stream.write(Buffer.from([protocol.codes['disconnect'] << 4]))

        // Length
        writeVarByteInt(stream, length)

        // reason code in header
        if (version === 5) {
          stream.write(Buffer.from([reasonCode]))
        }

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }

        return true
      }

      function auth(packet, stream, opts) {
        var version = opts ? opts.protocolVersion : 4
        var settings = packet || {}
        var reasonCode = settings.reasonCode
        var properties = settings.properties
        var length = version === 5 ? 1 : 0

        if (version !== 5) stream.emit('error', new Error('Invalid mqtt version for auth packet'))

        // properies mqtt 5
        var propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
        if (!propertiesData) { return false }
        length += propertiesData.length

        // Header
        stream.write(Buffer.from([protocol.codes['auth'] << 4]))

        // Length
        writeVarByteInt(stream, length)

        // reason code in header
        stream.write(Buffer.from([reasonCode]))

        // properies mqtt 5
        if (propertiesData !== null) {
          propertiesData.write()
        }
        return true
      }

      /**
       * writeVarByteInt - write an MQTT style variable byte integer to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <Number> length - length (>0)
       * @returns <Number> number of bytes written
       *
       * @api private
       */

      var varByteIntCache = {}
      function writeVarByteInt(stream, num) {
        var buffer = varByteIntCache[num]

        if (!buffer) {
          buffer = genBufVariableByteInt(num).data
          if (num < 16384) varByteIntCache[num] = buffer
        }

        stream.write(buffer)
      }

      /**
       * writeString - write a utf8 string to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <String> string - string to write
       * @return <Number> number of bytes written
       *
       * @api private
       */

      function writeString(stream, string) {
        var strlen = Buffer.byteLength(string)
        writeNumber(stream, strlen)

        stream.write(string, 'utf8')
      }

      /**
       * writeStringPair - write a utf8 string pairs to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <String> name - string name to write
       * @param <String> value - string value to write
       * @return <Number> number of bytes written
       *
       * @api private
       */
      function writeStringPair(stream, name, value) {
        writeString(stream, name)
        writeString(stream, value)
      }

      /**
       * writeNumber - write a two byte number to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <String> number - number to write
       * @return <Number> number of bytes written
       *
       * @api private
       */
      function writeNumberCached(stream, number) {
        return stream.write(numCache[number])
      }
      function writeNumberGenerated(stream, number) {
        return stream.write(generateNumber(number))
      }
      function write4ByteNumber(stream, number) {
        return stream.write(generate4ByteBuffer(number))
      }
      /**
       * writeStringOrBuffer - write a String or Buffer with the its length prefix
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <String> toWrite - String or Buffer
       * @return <Number> number of bytes written
       */
      function writeStringOrBuffer(stream, toWrite) {
        if (typeof toWrite === 'string') {
          writeString(stream, toWrite)
        } else if (toWrite) {
          writeNumber(stream, toWrite.length)
          stream.write(toWrite)
        } else writeNumber(stream, 0)
      }

      function getProperties(stream, properties) {
        /* connect properties */
        if (typeof properties !== 'object' || properties.length != null) {
          return {
            length: 1,
            write: function () {
              writeProperties(stream, {}, 0)
            }
          }
        }
        var propertiesLength = 0
        function getLengthProperty(name) {
          var type = protocol.propertiesTypes[name]
          var value = properties[name]
          var length = 0
          switch (type) {
            case 'byte': {
              if (typeof value !== 'boolean') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + 1
              break
            }
            case 'int8': {
              if (typeof value !== 'number') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + 1
              break
            }
            case 'binary': {
              if (value && value === null) {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + Buffer.byteLength(value) + 2
              break
            }
            case 'int16': {
              if (typeof value !== 'number') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + 2
              break
            }
            case 'int32': {
              if (typeof value !== 'number') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + 4
              break
            }
            case 'var': {
              if (typeof value !== 'number') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + genBufVariableByteInt(value).length
              break
            }
            case 'string': {
              if (typeof value !== 'string') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += 1 + 2 + Buffer.byteLength(value.toString())
              break
            }
            case 'pair': {
              if (typeof value !== 'object') {
                stream.emit('error', new Error('Invalid ' + name))
                return false
              }
              length += Object.getOwnPropertyNames(value).reduce(function (result, name) {
                result += 1 + 2 + Buffer.byteLength(name.toString()) + 2 + Buffer.byteLength(value[name].toString())
                return result
              }, 0)
              break
            }
            default: {
              stream.emit('error', new Error('Invalid property ' + name))
              return false
            }
          }
          return length
        }
        if (properties) {
          for (var propName in properties) {
            var propLength = getLengthProperty(propName)
            if (!propLength) return false
            propertiesLength += propLength
          }
        }
        var propertiesLengthLength = genBufVariableByteInt(propertiesLength).length

        return {
          length: propertiesLengthLength + propertiesLength,
          write: function () {
            writeProperties(stream, properties, propertiesLength)
          }
        }
      }

      function getPropertiesByMaximumPacketSize(stream, properties, opts, length) {
        var mayEmptyProps = ['reasonString', 'userProperties']
        var maximumPacketSize = opts && opts.properties && opts.properties.maximumPacketSize ? opts.properties.maximumPacketSize : 0

        var propertiesData = getProperties(stream, properties)
        if (maximumPacketSize) {
          while (length + propertiesData.length > maximumPacketSize) {
            var currentMayEmptyProp = mayEmptyProps.shift()
            if (currentMayEmptyProp && properties[currentMayEmptyProp]) {
              delete properties[currentMayEmptyProp]
              propertiesData = getProperties(stream, properties)
            } else {
              return false
            }
          }
        }
        return propertiesData
      }

      function writeProperties(stream, properties, propertiesLength) {
        /* write properties to stream */
        writeVarByteInt(stream, propertiesLength)
        for (var propName in properties) {
          if (properties.hasOwnProperty(propName) && properties[propName] !== null) {
            var value = properties[propName]
            var type = protocol.propertiesTypes[propName]
            switch (type) {
              case 'byte': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                stream.write(Buffer.from([+value]))
                break
              }
              case 'int8': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                stream.write(Buffer.from([value]))
                break
              }
              case 'binary': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                writeStringOrBuffer(stream, value)
                break
              }
              case 'int16': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                writeNumber(stream, value)
                break
              }
              case 'int32': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                write4ByteNumber(stream, value)
                break
              }
              case 'var': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                writeVarByteInt(stream, value)
                break
              }
              case 'string': {
                stream.write(Buffer.from([protocol.properties[propName]]))
                writeString(stream, value)
                break
              }
              case 'pair': {
                Object.getOwnPropertyNames(value).forEach(function (name) {
                  stream.write(Buffer.from([protocol.properties[propName]]))
                  writeStringPair(stream, name.toString(), value[name].toString())
                })
                break
              }
              default: {
                stream.emit('error', new Error('Invalid property ' + propName))
                return false
              }
            }
          }
        }
      }

      function byteLength(bufOrString) {
        if (!bufOrString) return 0
        else if (bufOrString instanceof Buffer) return bufOrString.length
        else return Buffer.byteLength(bufOrString)
      }

      function isStringOrBuffer(field) {
        return typeof field === 'string' || field instanceof Buffer
      }

      module.exports = generate

    }, { "./constants": 90, "./numbers": 94, "process-nextick-args": 99, "safe-buffer": 118 }], 98: [function (require, module, exports) {
      var wrappy = require('wrappy')
      module.exports = wrappy(once)
      module.exports.strict = wrappy(onceStrict)

      once.proto = once(function () {
        Object.defineProperty(Function.prototype, 'once', {
          value: function () {
            return once(this)
          },
          configurable: true
        })

        Object.defineProperty(Function.prototype, 'onceStrict', {
          value: function () {
            return onceStrict(this)
          },
          configurable: true
        })
      })

      function once(fn) {
        var f = function () {
          if (f.called) return f.value
          f.called = true
          return f.value = fn.apply(this, arguments)
        }
        f.called = false
        return f
      }

      function onceStrict(fn) {
        var f = function () {
          if (f.called)
            throw new Error(f.onceError)
          f.called = true
          return f.value = fn.apply(this, arguments)
        }
        var name = fn.name || 'Function wrapped with `once`'
        f.onceError = name + " shouldn't be called more than once"
        f.called = false
        return f
      }

    }, { "wrappy": 139 }], 99: [function (require, module, exports) {
      (function (process) {
        'use strict';

        if (typeof process === 'undefined' ||
          !process.version ||
          process.version.indexOf('v0.') === 0 ||
          process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
          module.exports = { nextTick: nextTick };
        } else {
          module.exports = process
        }

        function nextTick(fn, arg1, arg2, arg3) {
          if (typeof fn !== 'function') {
            throw new TypeError('"callback" argument must be a function');
          }
          var len = arguments.length;
          var args, i;
          switch (len) {
            case 0:
            case 1:
              return process.nextTick(fn);
            case 2:
              return process.nextTick(function afterTickOne() {
                fn.call(null, arg1);
              });
            case 3:
              return process.nextTick(function afterTickTwo() {
                fn.call(null, arg1, arg2);
              });
            case 4:
              return process.nextTick(function afterTickThree() {
                fn.call(null, arg1, arg2, arg3);
              });
            default:
              args = new Array(len - 1);
              i = 0;
              while (i < args.length) {
                args[i++] = arguments[i];
              }
              return process.nextTick(function afterTick() {
                fn.apply(null, args);
              });
          }
        }


      }).call(this, require('_process'))
    }, { "_process": 100 }], 100: [function (require, module, exports) {
      // shim for using process in browser
      var process = module.exports = {};

      // cached from whatever global is present so that test runners that stub it
      // don't break things.  But we need to wrap it in a try catch in case it is
      // wrapped in strict mode code which doesn't define any globals.  It's inside a
      // function because try/catches deoptimize in certain engines.

      var cachedSetTimeout;
      var cachedClearTimeout;

      function defaultSetTimout() {
        throw new Error('setTimeout has not been defined');
      }
      function defaultClearTimeout() {
        throw new Error('clearTimeout has not been defined');
      }
      (function () {
        try {
          if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
          } else {
            cachedSetTimeout = defaultSetTimout;
          }
        } catch (e) {
          cachedSetTimeout = defaultSetTimout;
        }
        try {
          if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
          } else {
            cachedClearTimeout = defaultClearTimeout;
          }
        } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
        }
      }())
      function runTimeout(fun) {
        if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
        }
        // if setTimeout wasn't available but was latter defined
        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
          }
        }


      }
      function runClearTimeout(marker) {
        if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
        }
        // if clearTimeout wasn't available but was latter defined
        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
          }
        }



      }
      var queue = [];
      var draining = false;
      var currentQueue;
      var queueIndex = -1;

      function cleanUpNextTick() {
        if (!draining || !currentQueue) {
          return;
        }
        draining = false;
        if (currentQueue.length) {
          queue = currentQueue.concat(queue);
        } else {
          queueIndex = -1;
        }
        if (queue.length) {
          drainQueue();
        }
      }

      function drainQueue() {
        if (draining) {
          return;
        }
        var timeout = runTimeout(cleanUpNextTick);
        draining = true;

        var len = queue.length;
        while (len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
            if (currentQueue) {
              currentQueue[queueIndex].run();
            }
          }
          queueIndex = -1;
          len = queue.length;
        }
        currentQueue = null;
        draining = false;
        runClearTimeout(timeout);
      }

      process.nextTick = function (fun) {
        var args = new Array(arguments.length - 1);
        if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
          }
        }
        queue.push(new Item(fun, args));
        if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
        }
      };

      // v8 likes predictible objects
      function Item(fun, array) {
        this.fun = fun;
        this.array = array;
      }
      Item.prototype.run = function () {
        this.fun.apply(null, this.array);
      };
      process.title = 'browser';
      process.browser = true;
      process.env = {};
      process.argv = [];
      process.version = ''; // empty string to avoid regexp issues
      process.versions = {};

      function noop() { }

      process.on = noop;
      process.addListener = noop;
      process.once = noop;
      process.off = noop;
      process.removeListener = noop;
      process.removeAllListeners = noop;
      process.emit = noop;
      process.prependListener = noop;
      process.prependOnceListener = noop;

      process.listeners = function (name) { return [] }

      process.binding = function (name) {
        throw new Error('process.binding is not supported');
      };

      process.cwd = function () { return '/' };
      process.chdir = function (dir) {
        throw new Error('process.chdir is not supported');
      };
      process.umask = function () { return 0; };

    }, {}], 101: [function (require, module, exports) {
      (function (global) {
        /*! https://mths.be/punycode v1.4.1 by @mathias */
        ; (function (root) {

          /** Detect free variables */
          var freeExports = typeof exports == 'object' && exports &&
            !exports.nodeType && exports;
          var freeModule = typeof module == 'object' && module &&
            !module.nodeType && module;
          var freeGlobal = typeof global == 'object' && global;
          if (
            freeGlobal.global === freeGlobal ||
            freeGlobal.window === freeGlobal ||
            freeGlobal.self === freeGlobal
          ) {
            root = freeGlobal;
          }

          /**
           * The `punycode` object.
           * @name punycode
           * @type Object
           */
          var punycode,

            /** Highest positive signed 32-bit float value */
            maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1

            /** Bootstring parameters */
            base = 36,
            tMin = 1,
            tMax = 26,
            skew = 38,
            damp = 700,
            initialBias = 72,
            initialN = 128, // 0x80
            delimiter = '-', // '\x2D'

            /** Regular expressions */
            regexPunycode = /^xn--/,
            regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
            regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

            /** Error messages */
            errors = {
              'overflow': 'Overflow: input needs wider integers to process',
              'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
              'invalid-input': 'Invalid input'
            },

            /** Convenience shortcuts */
            baseMinusTMin = base - tMin,
            floor = Math.floor,
            stringFromCharCode = String.fromCharCode,

            /** Temporary variable */
            key;

          /*--------------------------------------------------------------------------*/

          /**
           * A generic error utility function.
           * @private
           * @param {String} type The error type.
           * @returns {Error} Throws a `RangeError` with the applicable error message.
           */
          function error(type) {
            throw new RangeError(errors[type]);
          }

          /**
           * A generic `Array#map` utility function.
           * @private
           * @param {Array} array The array to iterate over.
           * @param {Function} callback The function that gets called for every array
           * item.
           * @returns {Array} A new array of values returned by the callback function.
           */
          function map(array, fn) {
            var length = array.length;
            var result = [];
            while (length--) {
              result[length] = fn(array[length]);
            }
            return result;
          }

          /**
           * A simple `Array#map`-like wrapper to work with domain name strings or email
           * addresses.
           * @private
           * @param {String} domain The domain name or email address.
           * @param {Function} callback The function that gets called for every
           * character.
           * @returns {Array} A new string of characters returned by the callback
           * function.
           */
          function mapDomain(string, fn) {
            var parts = string.split('@');
            var result = '';
            if (parts.length > 1) {
              // In email addresses, only the domain name should be punycoded. Leave
              // the local part (i.e. everything up to `@`) intact.
              result = parts[0] + '@';
              string = parts[1];
            }
            // Avoid `split(regex)` for IE8 compatibility. See #17.
            string = string.replace(regexSeparators, '\x2E');
            var labels = string.split('.');
            var encoded = map(labels, fn).join('.');
            return result + encoded;
          }

          /**
           * Creates an array containing the numeric code points of each Unicode
           * character in the string. While JavaScript uses UCS-2 internally,
           * this function will convert a pair of surrogate halves (each of which
           * UCS-2 exposes as separate characters) into a single code point,
           * matching UTF-16.
           * @see `punycode.ucs2.encode`
           * @see <https://mathiasbynens.be/notes/javascript-encoding>
           * @memberOf punycode.ucs2
           * @name decode
           * @param {String} string The Unicode input string (UCS-2).
           * @returns {Array} The new array of code points.
           */
          function ucs2decode(string) {
            var output = [],
              counter = 0,
              length = string.length,
              value,
              extra;
            while (counter < length) {
              value = string.charCodeAt(counter++);
              if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
                // high surrogate, and there is a next character
                extra = string.charCodeAt(counter++);
                if ((extra & 0xFC00) == 0xDC00) { // low surrogate
                  output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
                } else {
                  // unmatched surrogate; only append this code unit, in case the next
                  // code unit is the high surrogate of a surrogate pair
                  output.push(value);
                  counter--;
                }
              } else {
                output.push(value);
              }
            }
            return output;
          }

          /**
           * Creates a string based on an array of numeric code points.
           * @see `punycode.ucs2.decode`
           * @memberOf punycode.ucs2
           * @name encode
           * @param {Array} codePoints The array of numeric code points.
           * @returns {String} The new Unicode string (UCS-2).
           */
          function ucs2encode(array) {
            return map(array, function (value) {
              var output = '';
              if (value > 0xFFFF) {
                value -= 0x10000;
                output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
                value = 0xDC00 | value & 0x3FF;
              }
              output += stringFromCharCode(value);
              return output;
            }).join('');
          }

          /**
           * Converts a basic code point into a digit/integer.
           * @see `digitToBasic()`
           * @private
           * @param {Number} codePoint The basic numeric code point value.
           * @returns {Number} The numeric value of a basic code point (for use in
           * representing integers) in the range `0` to `base - 1`, or `base` if
           * the code point does not represent a value.
           */
          function basicToDigit(codePoint) {
            if (codePoint - 48 < 10) {
              return codePoint - 22;
            }
            if (codePoint - 65 < 26) {
              return codePoint - 65;
            }
            if (codePoint - 97 < 26) {
              return codePoint - 97;
            }
            return base;
          }

          /**
           * Converts a digit/integer into a basic code point.
           * @see `basicToDigit()`
           * @private
           * @param {Number} digit The numeric value of a basic code point.
           * @returns {Number} The basic code point whose value (when used for
           * representing integers) is `digit`, which needs to be in the range
           * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
           * used; else, the lowercase form is used. The behavior is undefined
           * if `flag` is non-zero and `digit` has no uppercase form.
           */
          function digitToBasic(digit, flag) {
            //  0..25 map to ASCII a..z or A..Z
            // 26..35 map to ASCII 0..9
            return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
          }

          /**
           * Bias adaptation function as per section 3.4 of RFC 3492.
           * https://tools.ietf.org/html/rfc3492#section-3.4
           * @private
           */
          function adapt(delta, numPoints, firstTime) {
            var k = 0;
            delta = firstTime ? floor(delta / damp) : delta >> 1;
            delta += floor(delta / numPoints);
            for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
              delta = floor(delta / baseMinusTMin);
            }
            return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
          }

          /**
           * Converts a Punycode string of ASCII-only symbols to a string of Unicode
           * symbols.
           * @memberOf punycode
           * @param {String} input The Punycode string of ASCII-only symbols.
           * @returns {String} The resulting string of Unicode symbols.
           */
          function decode(input) {
            // Don't use UCS-2
            var output = [],
              inputLength = input.length,
              out,
              i = 0,
              n = initialN,
              bias = initialBias,
              basic,
              j,
              index,
              oldi,
              w,
              k,
              digit,
              t,
              /** Cached calculation results */
              baseMinusT;

            // Handle the basic code points: let `basic` be the number of input code
            // points before the last delimiter, or `0` if there is none, then copy
            // the first basic code points to the output.

            basic = input.lastIndexOf(delimiter);
            if (basic < 0) {
              basic = 0;
            }

            for (j = 0; j < basic; ++j) {
              // if it's not a basic code point
              if (input.charCodeAt(j) >= 0x80) {
                error('not-basic');
              }
              output.push(input.charCodeAt(j));
            }

            // Main decoding loop: start just after the last delimiter if any basic code
            // points were copied; start at the beginning otherwise.

            for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {

              // `index` is the index of the next character to be consumed.
              // Decode a generalized variable-length integer into `delta`,
              // which gets added to `i`. The overflow checking is easier
              // if we increase `i` as we go, then subtract off its starting
              // value at the end to obtain `delta`.
              for (oldi = i, w = 1, k = base; /* no condition */; k += base) {

                if (index >= inputLength) {
                  error('invalid-input');
                }

                digit = basicToDigit(input.charCodeAt(index++));

                if (digit >= base || digit > floor((maxInt - i) / w)) {
                  error('overflow');
                }

                i += digit * w;
                t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

                if (digit < t) {
                  break;
                }

                baseMinusT = base - t;
                if (w > floor(maxInt / baseMinusT)) {
                  error('overflow');
                }

                w *= baseMinusT;

              }

              out = output.length + 1;
              bias = adapt(i - oldi, out, oldi == 0);

              // `i` was supposed to wrap around from `out` to `0`,
              // incrementing `n` each time, so we'll fix that now:
              if (floor(i / out) > maxInt - n) {
                error('overflow');
              }

              n += floor(i / out);
              i %= out;

              // Insert `n` at position `i` of the output
              output.splice(i++, 0, n);

            }

            return ucs2encode(output);
          }

          /**
           * Converts a string of Unicode symbols (e.g. a domain name label) to a
           * Punycode string of ASCII-only symbols.
           * @memberOf punycode
           * @param {String} input The string of Unicode symbols.
           * @returns {String} The resulting Punycode string of ASCII-only symbols.
           */
          function encode(input) {
            var n,
              delta,
              handledCPCount,
              basicLength,
              bias,
              j,
              m,
              q,
              k,
              t,
              currentValue,
              output = [],
              /** `inputLength` will hold the number of code points in `input`. */
              inputLength,
              /** Cached calculation results */
              handledCPCountPlusOne,
              baseMinusT,
              qMinusT;

            // Convert the input in UCS-2 to Unicode
            input = ucs2decode(input);

            // Cache the length
            inputLength = input.length;

            // Initialize the state
            n = initialN;
            delta = 0;
            bias = initialBias;

            // Handle the basic code points
            for (j = 0; j < inputLength; ++j) {
              currentValue = input[j];
              if (currentValue < 0x80) {
                output.push(stringFromCharCode(currentValue));
              }
            }

            handledCPCount = basicLength = output.length;

            // `handledCPCount` is the number of code points that have been handled;
            // `basicLength` is the number of basic code points.

            // Finish the basic string - if it is not empty - with a delimiter
            if (basicLength) {
              output.push(delimiter);
            }

            // Main encoding loop:
            while (handledCPCount < inputLength) {

              // All non-basic code points < n have been handled already. Find the next
              // larger one:
              for (m = maxInt, j = 0; j < inputLength; ++j) {
                currentValue = input[j];
                if (currentValue >= n && currentValue < m) {
                  m = currentValue;
                }
              }

              // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
              // but guard against overflow
              handledCPCountPlusOne = handledCPCount + 1;
              if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
                error('overflow');
              }

              delta += (m - n) * handledCPCountPlusOne;
              n = m;

              for (j = 0; j < inputLength; ++j) {
                currentValue = input[j];

                if (currentValue < n && ++delta > maxInt) {
                  error('overflow');
                }

                if (currentValue == n) {
                  // Represent delta as a generalized variable-length integer
                  for (q = delta, k = base; /* no condition */; k += base) {
                    t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
                    if (q < t) {
                      break;
                    }
                    qMinusT = q - t;
                    baseMinusT = base - t;
                    output.push(
                      stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
                    );
                    q = floor(qMinusT / baseMinusT);
                  }

                  output.push(stringFromCharCode(digitToBasic(q, 0)));
                  bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
                  delta = 0;
                  ++handledCPCount;
                }
              }

              ++delta;
              ++n;

            }
            return output.join('');
          }

          /**
           * Converts a Punycode string representing a domain name or an email address
           * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
           * it doesn't matter if you call it on a string that has already been
           * converted to Unicode.
           * @memberOf punycode
           * @param {String} input The Punycoded domain name or email address to
           * convert to Unicode.
           * @returns {String} The Unicode representation of the given Punycode
           * string.
           */
          function toUnicode(input) {
            return mapDomain(input, function (string) {
              return regexPunycode.test(string)
                ? decode(string.slice(4).toLowerCase())
                : string;
            });
          }

          /**
           * Converts a Unicode string representing a domain name or an email address to
           * Punycode. Only the non-ASCII parts of the domain name will be converted,
           * i.e. it doesn't matter if you call it with a domain that's already in
           * ASCII.
           * @memberOf punycode
           * @param {String} input The domain name or email address to convert, as a
           * Unicode string.
           * @returns {String} The Punycode representation of the given domain name or
           * email address.
           */
          function toASCII(input) {
            return mapDomain(input, function (string) {
              return regexNonASCII.test(string)
                ? 'xn--' + encode(string)
                : string;
            });
          }

          /*--------------------------------------------------------------------------*/

          /** Define the public API */
          punycode = {
            /**
             * A string representing the current Punycode.js version number.
             * @memberOf punycode
             * @type String
             */
            'version': '1.4.1',
            /**
             * An object of methods to convert from JavaScript's internal character
             * representation (UCS-2) to Unicode code points, and back.
             * @see <https://mathiasbynens.be/notes/javascript-encoding>
             * @memberOf punycode
             * @type Object
             */
            'ucs2': {
              'decode': ucs2decode,
              'encode': ucs2encode
            },
            'decode': decode,
            'encode': encode,
            'toASCII': toASCII,
            'toUnicode': toUnicode
          };

          /** Expose `punycode` */
          // Some AMD build optimizers, like r.js, check for specific condition patterns
          // like the following:
          if (
            typeof define == 'function' &&
            typeof define.amd == 'object' &&
            define.amd
          ) {
            define('punycode', function () {
              return punycode;
            });
          } else if (freeExports && freeModule) {
            if (module.exports == freeExports) {
              // in Node.js, io.js, or RingoJS v0.8.0+
              freeModule.exports = punycode;
            } else {
              // in Narwhal or RingoJS v0.7.0-
              for (key in punycode) {
                punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
              }
            }
          } else {
            // in Rhino or a web browser
            root.punycode = punycode;
          }

        }(this));

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}], 102: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      // If obj.hasOwnProperty has been overridden, then calling
      // obj.hasOwnProperty(prop) will break.
      // See: https://github.com/joyent/node/issues/1707
      function hasOwnProperty(obj, prop) {
        return Object.prototype.hasOwnProperty.call(obj, prop);
      }

      module.exports = function (qs, sep, eq, options) {
        sep = sep || '&';
        eq = eq || '=';
        var obj = {};

        if (typeof qs !== 'string' || qs.length === 0) {
          return obj;
        }

        var regexp = /\+/g;
        qs = qs.split(sep);

        var maxKeys = 1000;
        if (options && typeof options.maxKeys === 'number') {
          maxKeys = options.maxKeys;
        }

        var len = qs.length;
        // maxKeys <= 0 means that we should not limit keys count
        if (maxKeys > 0 && len > maxKeys) {
          len = maxKeys;
        }

        for (var i = 0; i < len; ++i) {
          var x = qs[i].replace(regexp, '%20'),
            idx = x.indexOf(eq),
            kstr, vstr, k, v;

          if (idx >= 0) {
            kstr = x.substr(0, idx);
            vstr = x.substr(idx + 1);
          } else {
            kstr = x;
            vstr = '';
          }

          k = decodeURIComponent(kstr);
          v = decodeURIComponent(vstr);

          if (!hasOwnProperty(obj, k)) {
            obj[k] = v;
          } else if (isArray(obj[k])) {
            obj[k].push(v);
          } else {
            obj[k] = [obj[k], v];
          }
        }

        return obj;
      };

      var isArray = Array.isArray || function (xs) {
        return Object.prototype.toString.call(xs) === '[object Array]';
      };

    }, {}], 103: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      var stringifyPrimitive = function (v) {
        switch (typeof v) {
          case 'string':
            return v;

          case 'boolean':
            return v ? 'true' : 'false';

          case 'number':
            return isFinite(v) ? v : '';

          default:
            return '';
        }
      };

      module.exports = function (obj, sep, eq, name) {
        sep = sep || '&';
        eq = eq || '=';
        if (obj === null) {
          obj = undefined;
        }

        if (typeof obj === 'object') {
          return map(objectKeys(obj), function (k) {
            var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
            if (isArray(obj[k])) {
              return map(obj[k], function (v) {
                return ks + encodeURIComponent(stringifyPrimitive(v));
              }).join(sep);
            } else {
              return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
            }
          }).join(sep);

        }

        if (!name) return '';
        return encodeURIComponent(stringifyPrimitive(name)) + eq +
          encodeURIComponent(stringifyPrimitive(obj));
      };

      var isArray = Array.isArray || function (xs) {
        return Object.prototype.toString.call(xs) === '[object Array]';
      };

      function map(xs, f) {
        if (xs.map) return xs.map(f);
        var res = [];
        for (var i = 0; i < xs.length; i++) {
          res.push(f(xs[i], i));
        }
        return res;
      }

      var objectKeys = Object.keys || function (obj) {
        var res = [];
        for (var key in obj) {
          if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
        }
        return res;
      };

    }, {}], 104: [function (require, module, exports) {
      'use strict';

      exports.decode = exports.parse = require('./decode');
      exports.encode = exports.stringify = require('./encode');

    }, { "./decode": 102, "./encode": 103 }], 105: [function (require, module, exports) {
      module.exports = require('./lib/_stream_duplex.js');

    }, { "./lib/_stream_duplex.js": 106 }], 106: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      // a duplex stream is just a stream that is both readable and writable.
      // Since JS doesn't have multiple prototypal inheritance, this class
      // prototypally inherits from Readable, and then parasitically from
      // Writable.

      'use strict';

      /*<replacement>*/

      var pna = require('process-nextick-args');
      /*</replacement>*/

      /*<replacement>*/
      var objectKeys = Object.keys || function (obj) {
        var keys = [];
        for (var key in obj) {
          keys.push(key);
        } return keys;
      };
      /*</replacement>*/

      module.exports = Duplex;

      /*<replacement>*/
      var util = require('core-util-is');
      util.inherits = require('inherits');
      /*</replacement>*/

      var Readable = require('./_stream_readable');
      var Writable = require('./_stream_writable');

      util.inherits(Duplex, Readable);

      {
        // avoid scope creep, the keys array can then be collected
        var keys = objectKeys(Writable.prototype);
        for (var v = 0; v < keys.length; v++) {
          var method = keys[v];
          if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
        }
      }

      function Duplex(options) {
        if (!(this instanceof Duplex)) return new Duplex(options);

        Readable.call(this, options);
        Writable.call(this, options);

        if (options && options.readable === false) this.readable = false;

        if (options && options.writable === false) this.writable = false;

        this.allowHalfOpen = true;
        if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;

        this.once('end', onend);
      }

      Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function () {
          return this._writableState.highWaterMark;
        }
      });

      // the no-half-open enforcer
      function onend() {
        // if we allow half-open state, or if the writable side ended,
        // then we're ok.
        if (this.allowHalfOpen || this._writableState.ended) return;

        // no more data can be written.
        // But allow more writes to happen in this tick.
        pna.nextTick(onEndNT, this);
      }

      function onEndNT(self) {
        self.end();
      }

      Object.defineProperty(Duplex.prototype, 'destroyed', {
        get: function () {
          if (this._readableState === undefined || this._writableState === undefined) {
            return false;
          }
          return this._readableState.destroyed && this._writableState.destroyed;
        },
        set: function (value) {
          // we ignore the value if the stream
          // has not been initialized yet
          if (this._readableState === undefined || this._writableState === undefined) {
            return;
          }

          // backward compatibility, the user is explicitly
          // managing destroyed
          this._readableState.destroyed = value;
          this._writableState.destroyed = value;
        }
      });

      Duplex.prototype._destroy = function (err, cb) {
        this.push(null);
        this.end();

        pna.nextTick(cb, err);
      };
    }, { "./_stream_readable": 108, "./_stream_writable": 110, "core-util-is": 13, "inherits": 88, "process-nextick-args": 99 }], 107: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      // a passthrough stream.
      // basically just the most minimal sort of Transform stream.
      // Every written chunk gets output as-is.

      'use strict';

      module.exports = PassThrough;

      var Transform = require('./_stream_transform');

      /*<replacement>*/
      var util = require('core-util-is');
      util.inherits = require('inherits');
      /*</replacement>*/

      util.inherits(PassThrough, Transform);

      function PassThrough(options) {
        if (!(this instanceof PassThrough)) return new PassThrough(options);

        Transform.call(this, options);
      }

      PassThrough.prototype._transform = function (chunk, encoding, cb) {
        cb(null, chunk);
      };
    }, { "./_stream_transform": 109, "core-util-is": 13, "inherits": 88 }], 108: [function (require, module, exports) {
      (function (process, global) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        'use strict';

        /*<replacement>*/

        var pna = require('process-nextick-args');
        /*</replacement>*/

        module.exports = Readable;

        /*<replacement>*/
        var isArray = require('isarray');
        /*</replacement>*/

        /*<replacement>*/
        var Duplex;
        /*</replacement>*/

        Readable.ReadableState = ReadableState;

        /*<replacement>*/
        var EE = require('events').EventEmitter;

        var EElistenerCount = function (emitter, type) {
          return emitter.listeners(type).length;
        };
        /*</replacement>*/

        /*<replacement>*/
        var Stream = require('./internal/streams/stream');
        /*</replacement>*/

        /*<replacement>*/

        var Buffer = require('safe-buffer').Buffer;
        var OurUint8Array = global.Uint8Array || function () { };
        function _uint8ArrayToBuffer(chunk) {
          return Buffer.from(chunk);
        }
        function _isUint8Array(obj) {
          return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
        }

        /*</replacement>*/

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        /*<replacement>*/
        var debugUtil = require('util');
        var debug = void 0;
        if (debugUtil && debugUtil.debuglog) {
          debug = debugUtil.debuglog('stream');
        } else {
          debug = function () { };
        }
        /*</replacement>*/

        var BufferList = require('./internal/streams/BufferList');
        var destroyImpl = require('./internal/streams/destroy');
        var StringDecoder;

        util.inherits(Readable, Stream);

        var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];

        function prependListener(emitter, event, fn) {
          // Sadly this is not cacheable as some libraries bundle their own
          // event emitter implementation with them.
          if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);

          // This is a hack to make sure that our error handler is attached before any
          // userland ones.  NEVER DO THIS. This is here only because this code needs
          // to continue to work with older versions of Node.js that do not include
          // the prependListener() method. The goal is to eventually remove this hack.
          if (!emitter._events || !emitter._events[event]) emitter.on(event, fn); else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn); else emitter._events[event] = [fn, emitter._events[event]];
        }

        function ReadableState(options, stream) {
          Duplex = Duplex || require('./_stream_duplex');

          options = options || {};

          // Duplex streams are both readable and writable, but share
          // the same options object.
          // However, some cases require setting options to different
          // values for the readable and the writable sides of the duplex stream.
          // These options can be provided separately as readableXXX and writableXXX.
          var isDuplex = stream instanceof Duplex;

          // object stream flag. Used to make read(n) ignore n and to
          // make all the buffer merging and length checks go away
          this.objectMode = !!options.objectMode;

          if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;

          // the point at which it stops calling _read() to fill the buffer
          // Note: 0 is a valid value, means "don't call _read preemptively ever"
          var hwm = options.highWaterMark;
          var readableHwm = options.readableHighWaterMark;
          var defaultHwm = this.objectMode ? 16 : 16 * 1024;

          if (hwm || hwm === 0) this.highWaterMark = hwm; else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm; else this.highWaterMark = defaultHwm;

          // cast to ints.
          this.highWaterMark = Math.floor(this.highWaterMark);

          // A linked list is used to store data chunks instead of an array because the
          // linked list can remove elements from the beginning faster than
          // array.shift()
          this.buffer = new BufferList();
          this.length = 0;
          this.pipes = null;
          this.pipesCount = 0;
          this.flowing = null;
          this.ended = false;
          this.endEmitted = false;
          this.reading = false;

          // a flag to be able to tell if the event 'readable'/'data' is emitted
          // immediately, or on a later tick.  We set this to true at first, because
          // any actions that shouldn't happen until "later" should generally also
          // not happen before the first read call.
          this.sync = true;

          // whenever we return null, then we set a flag to say
          // that we're awaiting a 'readable' event emission.
          this.needReadable = false;
          this.emittedReadable = false;
          this.readableListening = false;
          this.resumeScheduled = false;

          // has it been destroyed
          this.destroyed = false;

          // Crypto is kind of old and crusty.  Historically, its default string
          // encoding is 'binary' so we have to make this configurable.
          // Everything else in the universe uses 'utf8', though.
          this.defaultEncoding = options.defaultEncoding || 'utf8';

          // the number of writers that are awaiting a drain event in .pipe()s
          this.awaitDrain = 0;

          // if true, a maybeReadMore has been scheduled
          this.readingMore = false;

          this.decoder = null;
          this.encoding = null;
          if (options.encoding) {
            if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
            this.decoder = new StringDecoder(options.encoding);
            this.encoding = options.encoding;
          }
        }

        function Readable(options) {
          Duplex = Duplex || require('./_stream_duplex');

          if (!(this instanceof Readable)) return new Readable(options);

          this._readableState = new ReadableState(options, this);

          // legacy
          this.readable = true;

          if (options) {
            if (typeof options.read === 'function') this._read = options.read;

            if (typeof options.destroy === 'function') this._destroy = options.destroy;
          }

          Stream.call(this);
        }

        Object.defineProperty(Readable.prototype, 'destroyed', {
          get: function () {
            if (this._readableState === undefined) {
              return false;
            }
            return this._readableState.destroyed;
          },
          set: function (value) {
            // we ignore the value if the stream
            // has not been initialized yet
            if (!this._readableState) {
              return;
            }

            // backward compatibility, the user is explicitly
            // managing destroyed
            this._readableState.destroyed = value;
          }
        });

        Readable.prototype.destroy = destroyImpl.destroy;
        Readable.prototype._undestroy = destroyImpl.undestroy;
        Readable.prototype._destroy = function (err, cb) {
          this.push(null);
          cb(err);
        };

        // Manually shove something into the read() buffer.
        // This returns true if the highWaterMark has not been hit yet,
        // similar to how Writable.write() returns true if you should
        // write() some more.
        Readable.prototype.push = function (chunk, encoding) {
          var state = this._readableState;
          var skipChunkCheck;

          if (!state.objectMode) {
            if (typeof chunk === 'string') {
              encoding = encoding || state.defaultEncoding;
              if (encoding !== state.encoding) {
                chunk = Buffer.from(chunk, encoding);
                encoding = '';
              }
              skipChunkCheck = true;
            }
          } else {
            skipChunkCheck = true;
          }

          return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
        };

        // Unshift should *always* be something directly out of read()
        Readable.prototype.unshift = function (chunk) {
          return readableAddChunk(this, chunk, null, true, false);
        };

        function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
          var state = stream._readableState;
          if (chunk === null) {
            state.reading = false;
            onEofChunk(stream, state);
          } else {
            var er;
            if (!skipChunkCheck) er = chunkInvalid(state, chunk);
            if (er) {
              stream.emit('error', er);
            } else if (state.objectMode || chunk && chunk.length > 0) {
              if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
                chunk = _uint8ArrayToBuffer(chunk);
              }

              if (addToFront) {
                if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event')); else addChunk(stream, state, chunk, true);
              } else if (state.ended) {
                stream.emit('error', new Error('stream.push() after EOF'));
              } else {
                state.reading = false;
                if (state.decoder && !encoding) {
                  chunk = state.decoder.write(chunk);
                  if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false); else maybeReadMore(stream, state);
                } else {
                  addChunk(stream, state, chunk, false);
                }
              }
            } else if (!addToFront) {
              state.reading = false;
            }
          }

          return needMoreData(state);
        }

        function addChunk(stream, state, chunk, addToFront) {
          if (state.flowing && state.length === 0 && !state.sync) {
            stream.emit('data', chunk);
            stream.read(0);
          } else {
            // update the buffer info.
            state.length += state.objectMode ? 1 : chunk.length;
            if (addToFront) state.buffer.unshift(chunk); else state.buffer.push(chunk);

            if (state.needReadable) emitReadable(stream);
          }
          maybeReadMore(stream, state);
        }

        function chunkInvalid(state, chunk) {
          var er;
          if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
            er = new TypeError('Invalid non-string/buffer chunk');
          }
          return er;
        }

        // if it's past the high water mark, we can push in some more.
        // Also, if we have no data yet, we can stand some
        // more bytes.  This is to work around cases where hwm=0,
        // such as the repl.  Also, if the push() triggered a
        // readable event, and the user called read(largeNumber) such that
        // needReadable was set, then we ought to push more, so that another
        // 'readable' event will be triggered.
        function needMoreData(state) {
          return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
        }

        Readable.prototype.isPaused = function () {
          return this._readableState.flowing === false;
        };

        // backwards compatibility.
        Readable.prototype.setEncoding = function (enc) {
          if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
          this._readableState.decoder = new StringDecoder(enc);
          this._readableState.encoding = enc;
          return this;
        };

        // Don't raise the hwm > 8MB
        var MAX_HWM = 0x800000;
        function computeNewHighWaterMark(n) {
          if (n >= MAX_HWM) {
            n = MAX_HWM;
          } else {
            // Get the next highest power of 2 to prevent increasing hwm excessively in
            // tiny amounts
            n--;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            n++;
          }
          return n;
        }

        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function howMuchToRead(n, state) {
          if (n <= 0 || state.length === 0 && state.ended) return 0;
          if (state.objectMode) return 1;
          if (n !== n) {
            // Only flow one buffer at a time
            if (state.flowing && state.length) return state.buffer.head.data.length; else return state.length;
          }
          // If we're asking for more than the current hwm, then raise the hwm.
          if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
          if (n <= state.length) return n;
          // Don't have enough
          if (!state.ended) {
            state.needReadable = true;
            return 0;
          }
          return state.length;
        }

        // you can override either this method, or the async _read(n) below.
        Readable.prototype.read = function (n) {
          debug('read', n);
          n = parseInt(n, 10);
          var state = this._readableState;
          var nOrig = n;

          if (n !== 0) state.emittedReadable = false;

          // if we're doing read(0) to trigger a readable event, but we
          // already have a bunch of data in the buffer, then just trigger
          // the 'readable' event and move on.
          if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
            debug('read: emitReadable', state.length, state.ended);
            if (state.length === 0 && state.ended) endReadable(this); else emitReadable(this);
            return null;
          }

          n = howMuchToRead(n, state);

          // if we've ended, and we're now clear, then finish it up.
          if (n === 0 && state.ended) {
            if (state.length === 0) endReadable(this);
            return null;
          }

          // All the actual chunk generation logic needs to be
          // *below* the call to _read.  The reason is that in certain
          // synthetic stream cases, such as passthrough streams, _read
          // may be a completely synchronous operation which may change
          // the state of the read buffer, providing enough data when
          // before there was *not* enough.
          //
          // So, the steps are:
          // 1. Figure out what the state of things will be after we do
          // a read from the buffer.
          //
          // 2. If that resulting state will trigger a _read, then call _read.
          // Note that this may be asynchronous, or synchronous.  Yes, it is
          // deeply ugly to write APIs this way, but that still doesn't mean
          // that the Readable class should behave improperly, as streams are
          // designed to be sync/async agnostic.
          // Take note if the _read call is sync or async (ie, if the read call
          // has returned yet), so that we know whether or not it's safe to emit
          // 'readable' etc.
          //
          // 3. Actually pull the requested chunks out of the buffer and return.

          // if we need a readable event, then we need to do some reading.
          var doRead = state.needReadable;
          debug('need readable', doRead);

          // if we currently have less than the highWaterMark, then also read some
          if (state.length === 0 || state.length - n < state.highWaterMark) {
            doRead = true;
            debug('length less than watermark', doRead);
          }

          // however, if we've ended, then there's no point, and if we're already
          // reading, then it's unnecessary.
          if (state.ended || state.reading) {
            doRead = false;
            debug('reading or ended', doRead);
          } else if (doRead) {
            debug('do read');
            state.reading = true;
            state.sync = true;
            // if the length is currently zero, then we *need* a readable event.
            if (state.length === 0) state.needReadable = true;
            // call internal read method
            this._read(state.highWaterMark);
            state.sync = false;
            // If _read pushed data synchronously, then `reading` will be false,
            // and we need to re-evaluate how much data we can return to the user.
            if (!state.reading) n = howMuchToRead(nOrig, state);
          }

          var ret;
          if (n > 0) ret = fromList(n, state); else ret = null;

          if (ret === null) {
            state.needReadable = true;
            n = 0;
          } else {
            state.length -= n;
          }

          if (state.length === 0) {
            // If we have nothing in the buffer, then we want to know
            // as soon as we *do* get something into the buffer.
            if (!state.ended) state.needReadable = true;

            // If we tried to read() past the EOF, then emit end on the next tick.
            if (nOrig !== n && state.ended) endReadable(this);
          }

          if (ret !== null) this.emit('data', ret);

          return ret;
        };

        function onEofChunk(stream, state) {
          if (state.ended) return;
          if (state.decoder) {
            var chunk = state.decoder.end();
            if (chunk && chunk.length) {
              state.buffer.push(chunk);
              state.length += state.objectMode ? 1 : chunk.length;
            }
          }
          state.ended = true;

          // emit 'readable' now to make sure it gets picked up.
          emitReadable(stream);
        }

        // Don't emit readable right away in sync mode, because this can trigger
        // another read() call => stack overflow.  This way, it might trigger
        // a nextTick recursion warning, but that's not so bad.
        function emitReadable(stream) {
          var state = stream._readableState;
          state.needReadable = false;
          if (!state.emittedReadable) {
            debug('emitReadable', state.flowing);
            state.emittedReadable = true;
            if (state.sync) pna.nextTick(emitReadable_, stream); else emitReadable_(stream);
          }
        }

        function emitReadable_(stream) {
          debug('emit readable');
          stream.emit('readable');
          flow(stream);
        }

        // at this point, the user has presumably seen the 'readable' event,
        // and called read() to consume some data.  that may have triggered
        // in turn another _read(n) call, in which case reading = true if
        // it's in progress.
        // However, if we're not ended, or reading, and the length < hwm,
        // then go ahead and try to read some more preemptively.
        function maybeReadMore(stream, state) {
          if (!state.readingMore) {
            state.readingMore = true;
            pna.nextTick(maybeReadMore_, stream, state);
          }
        }

        function maybeReadMore_(stream, state) {
          var len = state.length;
          while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
            debug('maybeReadMore read 0');
            stream.read(0);
            if (len === state.length)
              // didn't get any data, stop spinning.
              break; else len = state.length;
          }
          state.readingMore = false;
        }

        // abstract method.  to be overridden in specific implementation classes.
        // call cb(er, data) where data is <= n in length.
        // for virtual (non-string, non-buffer) streams, "length" is somewhat
        // arbitrary, and perhaps not very meaningful.
        Readable.prototype._read = function (n) {
          this.emit('error', new Error('_read() is not implemented'));
        };

        Readable.prototype.pipe = function (dest, pipeOpts) {
          var src = this;
          var state = this._readableState;

          switch (state.pipesCount) {
            case 0:
              state.pipes = dest;
              break;
            case 1:
              state.pipes = [state.pipes, dest];
              break;
            default:
              state.pipes.push(dest);
              break;
          }
          state.pipesCount += 1;
          debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);

          var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;

          var endFn = doEnd ? onend : unpipe;
          if (state.endEmitted) pna.nextTick(endFn); else src.once('end', endFn);

          dest.on('unpipe', onunpipe);
          function onunpipe(readable, unpipeInfo) {
            debug('onunpipe');
            if (readable === src) {
              if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
                unpipeInfo.hasUnpiped = true;
                cleanup();
              }
            }
          }

          function onend() {
            debug('onend');
            dest.end();
          }

          // when the dest drains, it reduces the awaitDrain counter
          // on the source.  This would be more elegant with a .once()
          // handler in flow(), but adding and removing repeatedly is
          // too slow.
          var ondrain = pipeOnDrain(src);
          dest.on('drain', ondrain);

          var cleanedUp = false;
          function cleanup() {
            debug('cleanup');
            // cleanup event handlers once the pipe is broken
            dest.removeListener('close', onclose);
            dest.removeListener('finish', onfinish);
            dest.removeListener('drain', ondrain);
            dest.removeListener('error', onerror);
            dest.removeListener('unpipe', onunpipe);
            src.removeListener('end', onend);
            src.removeListener('end', unpipe);
            src.removeListener('data', ondata);

            cleanedUp = true;

            // if the reader is waiting for a drain event from this
            // specific writer, then it would cause it to never start
            // flowing again.
            // So, if this is awaiting a drain, then we just call it now.
            // If we don't know, then assume that we are waiting for one.
            if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
          }

          // If the user pushes more data while we're writing to dest then we'll end up
          // in ondata again. However, we only want to increase awaitDrain once because
          // dest will only emit one 'drain' event for the multiple writes.
          // => Introduce a guard on increasing awaitDrain.
          var increasedAwaitDrain = false;
          src.on('data', ondata);
          function ondata(chunk) {
            debug('ondata');
            increasedAwaitDrain = false;
            var ret = dest.write(chunk);
            if (false === ret && !increasedAwaitDrain) {
              // If the user unpiped during `dest.write()`, it is possible
              // to get stuck in a permanently paused state if that write
              // also returned false.
              // => Check whether `dest` is still a piping destination.
              if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
                debug('false write response, pause', src._readableState.awaitDrain);
                src._readableState.awaitDrain++;
                increasedAwaitDrain = true;
              }
              src.pause();
            }
          }

          // if the dest has an error, then stop piping into it.
          // however, don't suppress the throwing behavior for this.
          function onerror(er) {
            debug('onerror', er);
            unpipe();
            dest.removeListener('error', onerror);
            if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
          }

          // Make sure our error handler is attached before userland ones.
          prependListener(dest, 'error', onerror);

          // Both close and finish should trigger unpipe, but only once.
          function onclose() {
            dest.removeListener('finish', onfinish);
            unpipe();
          }
          dest.once('close', onclose);
          function onfinish() {
            debug('onfinish');
            dest.removeListener('close', onclose);
            unpipe();
          }
          dest.once('finish', onfinish);

          function unpipe() {
            debug('unpipe');
            src.unpipe(dest);
          }

          // tell the dest that it's being piped to
          dest.emit('pipe', src);

          // start the flow if it hasn't been started already.
          if (!state.flowing) {
            debug('pipe resume');
            src.resume();
          }

          return dest;
        };

        function pipeOnDrain(src) {
          return function () {
            var state = src._readableState;
            debug('pipeOnDrain', state.awaitDrain);
            if (state.awaitDrain) state.awaitDrain--;
            if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
              state.flowing = true;
              flow(src);
            }
          };
        }

        Readable.prototype.unpipe = function (dest) {
          var state = this._readableState;
          var unpipeInfo = { hasUnpiped: false };

          // if we're not piping anywhere, then do nothing.
          if (state.pipesCount === 0) return this;

          // just one destination.  most common case.
          if (state.pipesCount === 1) {
            // passed in one, but it's not the right one.
            if (dest && dest !== state.pipes) return this;

            if (!dest) dest = state.pipes;

            // got a match.
            state.pipes = null;
            state.pipesCount = 0;
            state.flowing = false;
            if (dest) dest.emit('unpipe', this, unpipeInfo);
            return this;
          }

          // slow case. multiple pipe destinations.

          if (!dest) {
            // remove all.
            var dests = state.pipes;
            var len = state.pipesCount;
            state.pipes = null;
            state.pipesCount = 0;
            state.flowing = false;

            for (var i = 0; i < len; i++) {
              dests[i].emit('unpipe', this, unpipeInfo);
            } return this;
          }

          // try to find the right one.
          var index = indexOf(state.pipes, dest);
          if (index === -1) return this;

          state.pipes.splice(index, 1);
          state.pipesCount -= 1;
          if (state.pipesCount === 1) state.pipes = state.pipes[0];

          dest.emit('unpipe', this, unpipeInfo);

          return this;
        };

        // set up data events if they are asked for
        // Ensure readable listeners eventually get something
        Readable.prototype.on = function (ev, fn) {
          var res = Stream.prototype.on.call(this, ev, fn);

          if (ev === 'data') {
            // Start flowing on next tick if stream isn't explicitly paused
            if (this._readableState.flowing !== false) this.resume();
          } else if (ev === 'readable') {
            var state = this._readableState;
            if (!state.endEmitted && !state.readableListening) {
              state.readableListening = state.needReadable = true;
              state.emittedReadable = false;
              if (!state.reading) {
                pna.nextTick(nReadingNextTick, this);
              } else if (state.length) {
                emitReadable(this);
              }
            }
          }

          return res;
        };
        Readable.prototype.addListener = Readable.prototype.on;

        function nReadingNextTick(self) {
          debug('readable nexttick read 0');
          self.read(0);
        }

        // pause() and resume() are remnants of the legacy readable stream API
        // If the user uses them, then switch into old mode.
        Readable.prototype.resume = function () {
          var state = this._readableState;
          if (!state.flowing) {
            debug('resume');
            state.flowing = true;
            resume(this, state);
          }
          return this;
        };

        function resume(stream, state) {
          if (!state.resumeScheduled) {
            state.resumeScheduled = true;
            pna.nextTick(resume_, stream, state);
          }
        }

        function resume_(stream, state) {
          if (!state.reading) {
            debug('resume read 0');
            stream.read(0);
          }

          state.resumeScheduled = false;
          state.awaitDrain = 0;
          stream.emit('resume');
          flow(stream);
          if (state.flowing && !state.reading) stream.read(0);
        }

        Readable.prototype.pause = function () {
          debug('call pause flowing=%j', this._readableState.flowing);
          if (false !== this._readableState.flowing) {
            debug('pause');
            this._readableState.flowing = false;
            this.emit('pause');
          }
          return this;
        };

        function flow(stream) {
          var state = stream._readableState;
          debug('flow', state.flowing);
          while (state.flowing && stream.read() !== null) { }
        }

        // wrap an old-style stream as the async data source.
        // This is *not* part of the readable stream interface.
        // It is an ugly unfortunate mess of history.
        Readable.prototype.wrap = function (stream) {
          var _this = this;

          var state = this._readableState;
          var paused = false;

          stream.on('end', function () {
            debug('wrapped end');
            if (state.decoder && !state.ended) {
              var chunk = state.decoder.end();
              if (chunk && chunk.length) _this.push(chunk);
            }

            _this.push(null);
          });

          stream.on('data', function (chunk) {
            debug('wrapped data');
            if (state.decoder) chunk = state.decoder.write(chunk);

            // don't skip over falsy values in objectMode
            if (state.objectMode && (chunk === null || chunk === undefined)) return; else if (!state.objectMode && (!chunk || !chunk.length)) return;

            var ret = _this.push(chunk);
            if (!ret) {
              paused = true;
              stream.pause();
            }
          });

          // proxy all the other methods.
          // important when wrapping filters and duplexes.
          for (var i in stream) {
            if (this[i] === undefined && typeof stream[i] === 'function') {
              this[i] = function (method) {
                return function () {
                  return stream[method].apply(stream, arguments);
                };
              }(i);
            }
          }

          // proxy certain important events.
          for (var n = 0; n < kProxyEvents.length; n++) {
            stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
          }

          // when we try to consume some more bytes, simply unpause the
          // underlying stream.
          this._read = function (n) {
            debug('wrapped _read', n);
            if (paused) {
              paused = false;
              stream.resume();
            }
          };

          return this;
        };

        Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
          // making it explicit this property is not enumerable
          // because otherwise some prototype manipulation in
          // userland will fail
          enumerable: false,
          get: function () {
            return this._readableState.highWaterMark;
          }
        });

        // exposed for testing purposes only.
        Readable._fromList = fromList;

        // Pluck off n bytes from an array of buffers.
        // Length is the combined lengths of all the buffers in the list.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function fromList(n, state) {
          // nothing buffered
          if (state.length === 0) return null;

          var ret;
          if (state.objectMode) ret = state.buffer.shift(); else if (!n || n >= state.length) {
            // read it all, truncate the list
            if (state.decoder) ret = state.buffer.join(''); else if (state.buffer.length === 1) ret = state.buffer.head.data; else ret = state.buffer.concat(state.length);
            state.buffer.clear();
          } else {
            // read part of list
            ret = fromListPartial(n, state.buffer, state.decoder);
          }

          return ret;
        }

        // Extracts only enough buffered data to satisfy the amount requested.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function fromListPartial(n, list, hasStrings) {
          var ret;
          if (n < list.head.data.length) {
            // slice is the same for buffers and strings
            ret = list.head.data.slice(0, n);
            list.head.data = list.head.data.slice(n);
          } else if (n === list.head.data.length) {
            // first chunk is a perfect match
            ret = list.shift();
          } else {
            // result spans more than one buffer
            ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
          }
          return ret;
        }

        // Copies a specified amount of characters from the list of buffered data
        // chunks.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function copyFromBufferString(n, list) {
          var p = list.head;
          var c = 1;
          var ret = p.data;
          n -= ret.length;
          while (p = p.next) {
            var str = p.data;
            var nb = n > str.length ? str.length : n;
            if (nb === str.length) ret += str; else ret += str.slice(0, n);
            n -= nb;
            if (n === 0) {
              if (nb === str.length) {
                ++c;
                if (p.next) list.head = p.next; else list.head = list.tail = null;
              } else {
                list.head = p;
                p.data = str.slice(nb);
              }
              break;
            }
            ++c;
          }
          list.length -= c;
          return ret;
        }

        // Copies a specified amount of bytes from the list of buffered data chunks.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function copyFromBuffer(n, list) {
          var ret = Buffer.allocUnsafe(n);
          var p = list.head;
          var c = 1;
          p.data.copy(ret);
          n -= p.data.length;
          while (p = p.next) {
            var buf = p.data;
            var nb = n > buf.length ? buf.length : n;
            buf.copy(ret, ret.length - n, 0, nb);
            n -= nb;
            if (n === 0) {
              if (nb === buf.length) {
                ++c;
                if (p.next) list.head = p.next; else list.head = list.tail = null;
              } else {
                list.head = p;
                p.data = buf.slice(nb);
              }
              break;
            }
            ++c;
          }
          list.length -= c;
          return ret;
        }

        function endReadable(stream) {
          var state = stream._readableState;

          // If we get here before consuming all the bytes, then that is a
          // bug in node.  Should never happen.
          if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');

          if (!state.endEmitted) {
            state.ended = true;
            pna.nextTick(endReadableNT, state, stream);
          }
        }

        function endReadableNT(state, stream) {
          // Check that we didn't get one last unshift.
          if (!state.endEmitted && state.length === 0) {
            state.endEmitted = true;
            stream.readable = false;
            stream.emit('end');
          }
        }

        function indexOf(xs, x) {
          for (var i = 0, l = xs.length; i < l; i++) {
            if (xs[i] === x) return i;
          }
          return -1;
        }
      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, { "./_stream_duplex": 106, "./internal/streams/BufferList": 111, "./internal/streams/destroy": 112, "./internal/streams/stream": 113, "_process": 100, "core-util-is": 13, "events": 83, "inherits": 88, "isarray": 114, "process-nextick-args": 99, "safe-buffer": 118, "string_decoder/": 115, "util": 11 }], 109: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      // a transform stream is a readable/writable stream where you do
      // something with the data.  Sometimes it's called a "filter",
      // but that's not a great name for it, since that implies a thing where
      // some bits pass through, and others are simply ignored.  (That would
      // be a valid example of a transform, of course.)
      //
      // While the output is causally related to the input, it's not a
      // necessarily symmetric or synchronous transformation.  For example,
      // a zlib stream might take multiple plain-text writes(), and then
      // emit a single compressed chunk some time in the future.
      //
      // Here's how this works:
      //
      // The Transform stream has all the aspects of the readable and writable
      // stream classes.  When you write(chunk), that calls _write(chunk,cb)
      // internally, and returns false if there's a lot of pending writes
      // buffered up.  When you call read(), that calls _read(n) until
      // there's enough pending readable data buffered up.
      //
      // In a transform stream, the written data is placed in a buffer.  When
      // _read(n) is called, it transforms the queued up data, calling the
      // buffered _write cb's as it consumes chunks.  If consuming a single
      // written chunk would result in multiple output chunks, then the first
      // outputted bit calls the readcb, and subsequent chunks just go into
      // the read buffer, and will cause it to emit 'readable' if necessary.
      //
      // This way, back-pressure is actually determined by the reading side,
      // since _read has to be called to start processing a new chunk.  However,
      // a pathological inflate type of transform can cause excessive buffering
      // here.  For example, imagine a stream where every byte of input is
      // interpreted as an integer from 0-255, and then results in that many
      // bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
      // 1kb of data being output.  In this case, you could write a very small
      // amount of input, and end up with a very large amount of output.  In
      // such a pathological inflating mechanism, there'd be no way to tell
      // the system to stop doing the transform.  A single 4MB write could
      // cause the system to run out of memory.
      //
      // However, even in such a pathological case, only a single written chunk
      // would be consumed, and then the rest would wait (un-transformed) until
      // the results of the previous transformed chunk were consumed.

      'use strict';

      module.exports = Transform;

      var Duplex = require('./_stream_duplex');

      /*<replacement>*/
      var util = require('core-util-is');
      util.inherits = require('inherits');
      /*</replacement>*/

      util.inherits(Transform, Duplex);

      function afterTransform(er, data) {
        var ts = this._transformState;
        ts.transforming = false;

        var cb = ts.writecb;

        if (!cb) {
          return this.emit('error', new Error('write callback called multiple times'));
        }

        ts.writechunk = null;
        ts.writecb = null;

        if (data != null) // single equals check for both `null` and `undefined`
          this.push(data);

        cb(er);

        var rs = this._readableState;
        rs.reading = false;
        if (rs.needReadable || rs.length < rs.highWaterMark) {
          this._read(rs.highWaterMark);
        }
      }

      function Transform(options) {
        if (!(this instanceof Transform)) return new Transform(options);

        Duplex.call(this, options);

        this._transformState = {
          afterTransform: afterTransform.bind(this),
          needTransform: false,
          transforming: false,
          writecb: null,
          writechunk: null,
          writeencoding: null
        };

        // start out asking for a readable event once data is transformed.
        this._readableState.needReadable = true;

        // we have implemented the _read method, and done the other things
        // that Readable wants before the first _read call, so unset the
        // sync guard flag.
        this._readableState.sync = false;

        if (options) {
          if (typeof options.transform === 'function') this._transform = options.transform;

          if (typeof options.flush === 'function') this._flush = options.flush;
        }

        // When the writable side finishes, then flush out anything remaining.
        this.on('prefinish', prefinish);
      }

      function prefinish() {
        var _this = this;

        if (typeof this._flush === 'function') {
          this._flush(function (er, data) {
            done(_this, er, data);
          });
        } else {
          done(this, null, null);
        }
      }

      Transform.prototype.push = function (chunk, encoding) {
        this._transformState.needTransform = false;
        return Duplex.prototype.push.call(this, chunk, encoding);
      };

      // This is the part where you do stuff!
      // override this function in implementation classes.
      // 'chunk' is an input chunk.
      //
      // Call `push(newChunk)` to pass along transformed output
      // to the readable side.  You may call 'push' zero or more times.
      //
      // Call `cb(err)` when you are done with this chunk.  If you pass
      // an error, then that'll put the hurt on the whole operation.  If you
      // never call cb(), then you'll never get another chunk.
      Transform.prototype._transform = function (chunk, encoding, cb) {
        throw new Error('_transform() is not implemented');
      };

      Transform.prototype._write = function (chunk, encoding, cb) {
        var ts = this._transformState;
        ts.writecb = cb;
        ts.writechunk = chunk;
        ts.writeencoding = encoding;
        if (!ts.transforming) {
          var rs = this._readableState;
          if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
        }
      };

      // Doesn't matter what the args are here.
      // _transform does all the work.
      // That we got here means that the readable side wants more data.
      Transform.prototype._read = function (n) {
        var ts = this._transformState;

        if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
          ts.transforming = true;
          this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
        } else {
          // mark that we need a transform, so that any data that comes in
          // will get processed, now that we've asked for it.
          ts.needTransform = true;
        }
      };

      Transform.prototype._destroy = function (err, cb) {
        var _this2 = this;

        Duplex.prototype._destroy.call(this, err, function (err2) {
          cb(err2);
          _this2.emit('close');
        });
      };

      function done(stream, er, data) {
        if (er) return stream.emit('error', er);

        if (data != null) // single equals check for both `null` and `undefined`
          stream.push(data);

        // if there's nothing in the write buffer, then that means
        // that nothing more will ever be provided
        if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');

        if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');

        return stream.push(null);
      }
    }, { "./_stream_duplex": 106, "core-util-is": 13, "inherits": 88 }], 110: [function (require, module, exports) {
      (function (process, global, setImmediate) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        // A bit simpler than readable streams.
        // Implement an async ._write(chunk, encoding, cb), and it'll handle all
        // the drain event emission and buffering.

        'use strict';

        /*<replacement>*/

        var pna = require('process-nextick-args');
        /*</replacement>*/

        module.exports = Writable;

        /* <replacement> */
        function WriteReq(chunk, encoding, cb) {
          this.chunk = chunk;
          this.encoding = encoding;
          this.callback = cb;
          this.next = null;
        }

        // It seems a linked list but it is not
        // there will be only 2 of these for each stream
        function CorkedRequest(state) {
          var _this = this;

          this.next = null;
          this.entry = null;
          this.finish = function () {
            onCorkedFinish(_this, state);
          };
        }
        /* </replacement> */

        /*<replacement>*/
        var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
        /*</replacement>*/

        /*<replacement>*/
        var Duplex;
        /*</replacement>*/

        Writable.WritableState = WritableState;

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        /*<replacement>*/
        var internalUtil = {
          deprecate: require('util-deprecate')
        };
        /*</replacement>*/

        /*<replacement>*/
        var Stream = require('./internal/streams/stream');
        /*</replacement>*/

        /*<replacement>*/

        var Buffer = require('safe-buffer').Buffer;
        var OurUint8Array = global.Uint8Array || function () { };
        function _uint8ArrayToBuffer(chunk) {
          return Buffer.from(chunk);
        }
        function _isUint8Array(obj) {
          return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
        }

        /*</replacement>*/

        var destroyImpl = require('./internal/streams/destroy');

        util.inherits(Writable, Stream);

        function nop() { }

        function WritableState(options, stream) {
          Duplex = Duplex || require('./_stream_duplex');

          options = options || {};

          // Duplex streams are both readable and writable, but share
          // the same options object.
          // However, some cases require setting options to different
          // values for the readable and the writable sides of the duplex stream.
          // These options can be provided separately as readableXXX and writableXXX.
          var isDuplex = stream instanceof Duplex;

          // object stream flag to indicate whether or not this stream
          // contains buffers or objects.
          this.objectMode = !!options.objectMode;

          if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;

          // the point at which write() starts returning false
          // Note: 0 is a valid value, means that we always return false if
          // the entire buffer is not flushed immediately on write()
          var hwm = options.highWaterMark;
          var writableHwm = options.writableHighWaterMark;
          var defaultHwm = this.objectMode ? 16 : 16 * 1024;

          if (hwm || hwm === 0) this.highWaterMark = hwm; else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm; else this.highWaterMark = defaultHwm;

          // cast to ints.
          this.highWaterMark = Math.floor(this.highWaterMark);

          // if _final has been called
          this.finalCalled = false;

          // drain event flag.
          this.needDrain = false;
          // at the start of calling end()
          this.ending = false;
          // when end() has been called, and returned
          this.ended = false;
          // when 'finish' is emitted
          this.finished = false;

          // has it been destroyed
          this.destroyed = false;

          // should we decode strings into buffers before passing to _write?
          // this is here so that some node-core streams can optimize string
          // handling at a lower level.
          var noDecode = options.decodeStrings === false;
          this.decodeStrings = !noDecode;

          // Crypto is kind of old and crusty.  Historically, its default string
          // encoding is 'binary' so we have to make this configurable.
          // Everything else in the universe uses 'utf8', though.
          this.defaultEncoding = options.defaultEncoding || 'utf8';

          // not an actual buffer we keep track of, but a measurement
          // of how much we're waiting to get pushed to some underlying
          // socket or file.
          this.length = 0;

          // a flag to see when we're in the middle of a write.
          this.writing = false;

          // when true all writes will be buffered until .uncork() call
          this.corked = 0;

          // a flag to be able to tell if the onwrite cb is called immediately,
          // or on a later tick.  We set this to true at first, because any
          // actions that shouldn't happen until "later" should generally also
          // not happen before the first write call.
          this.sync = true;

          // a flag to know if we're processing previously buffered items, which
          // may call the _write() callback in the same tick, so that we don't
          // end up in an overlapped onwrite situation.
          this.bufferProcessing = false;

          // the callback that's passed to _write(chunk,cb)
          this.onwrite = function (er) {
            onwrite(stream, er);
          };

          // the callback that the user supplies to write(chunk,encoding,cb)
          this.writecb = null;

          // the amount that is being written when _write is called.
          this.writelen = 0;

          this.bufferedRequest = null;
          this.lastBufferedRequest = null;

          // number of pending user-supplied write callbacks
          // this must be 0 before 'finish' can be emitted
          this.pendingcb = 0;

          // emit prefinish if the only thing we're waiting for is _write cbs
          // This is relevant for synchronous Transform streams
          this.prefinished = false;

          // True if the error was already emitted and should not be thrown again
          this.errorEmitted = false;

          // count buffered requests
          this.bufferedRequestCount = 0;

          // allocate the first CorkedRequest, there is always
          // one allocated and free to use, and we maintain at most two
          this.corkedRequestsFree = new CorkedRequest(this);
        }

        WritableState.prototype.getBuffer = function getBuffer() {
          var current = this.bufferedRequest;
          var out = [];
          while (current) {
            out.push(current);
            current = current.next;
          }
          return out;
        };

        (function () {
          try {
            Object.defineProperty(WritableState.prototype, 'buffer', {
              get: internalUtil.deprecate(function () {
                return this.getBuffer();
              }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
            });
          } catch (_) { }
        })();

        // Test _writableState for inheritance to account for Duplex streams,
        // whose prototype chain only points to Readable.
        var realHasInstance;
        if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
          realHasInstance = Function.prototype[Symbol.hasInstance];
          Object.defineProperty(Writable, Symbol.hasInstance, {
            value: function (object) {
              if (realHasInstance.call(this, object)) return true;
              if (this !== Writable) return false;

              return object && object._writableState instanceof WritableState;
            }
          });
        } else {
          realHasInstance = function (object) {
            return object instanceof this;
          };
        }

        function Writable(options) {
          Duplex = Duplex || require('./_stream_duplex');

          // Writable ctor is applied to Duplexes, too.
          // `realHasInstance` is necessary because using plain `instanceof`
          // would return false, as no `_writableState` property is attached.

          // Trying to use the custom `instanceof` for Writable here will also break the
          // Node.js LazyTransform implementation, which has a non-trivial getter for
          // `_writableState` that would lead to infinite recursion.
          if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
            return new Writable(options);
          }

          this._writableState = new WritableState(options, this);

          // legacy.
          this.writable = true;

          if (options) {
            if (typeof options.write === 'function') this._write = options.write;

            if (typeof options.writev === 'function') this._writev = options.writev;

            if (typeof options.destroy === 'function') this._destroy = options.destroy;

            if (typeof options.final === 'function') this._final = options.final;
          }

          Stream.call(this);
        }

        // Otherwise people can pipe Writable streams, which is just wrong.
        Writable.prototype.pipe = function () {
          this.emit('error', new Error('Cannot pipe, not readable'));
        };

        function writeAfterEnd(stream, cb) {
          var er = new Error('write after end');
          // TODO: defer error events consistently everywhere, not just the cb
          stream.emit('error', er);
          pna.nextTick(cb, er);
        }

        // Checks that a user-supplied chunk is valid, especially for the particular
        // mode the stream is in. Currently this means that `null` is never accepted
        // and undefined/non-string values are only allowed in object mode.
        function validChunk(stream, state, chunk, cb) {
          var valid = true;
          var er = false;

          if (chunk === null) {
            er = new TypeError('May not write null values to stream');
          } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
            er = new TypeError('Invalid non-string/buffer chunk');
          }
          if (er) {
            stream.emit('error', er);
            pna.nextTick(cb, er);
            valid = false;
          }
          return valid;
        }

        Writable.prototype.write = function (chunk, encoding, cb) {
          var state = this._writableState;
          var ret = false;
          var isBuf = !state.objectMode && _isUint8Array(chunk);

          if (isBuf && !Buffer.isBuffer(chunk)) {
            chunk = _uint8ArrayToBuffer(chunk);
          }

          if (typeof encoding === 'function') {
            cb = encoding;
            encoding = null;
          }

          if (isBuf) encoding = 'buffer'; else if (!encoding) encoding = state.defaultEncoding;

          if (typeof cb !== 'function') cb = nop;

          // 注释
          if (state.ended) writeAfterEnd(this, cb); else if (isBuf || validChunk(this, state, chunk, cb)) {
            state.pendingcb++;
            ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
          }

          return ret;
        };

        Writable.prototype.cork = function () {
          var state = this._writableState;

          state.corked++;
        };

        Writable.prototype.uncork = function () {
          var state = this._writableState;

          if (state.corked) {
            state.corked--;

            if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
          }
        };

        Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
          // node::ParseEncoding() requires lower case.
          if (typeof encoding === 'string') encoding = encoding.toLowerCase();
          if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
          this._writableState.defaultEncoding = encoding;
          return this;
        };

        function decodeChunk(state, chunk, encoding) {
          if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
            chunk = Buffer.from(chunk, encoding);
          }
          return chunk;
        }

        Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
          // making it explicit this property is not enumerable
          // because otherwise some prototype manipulation in
          // userland will fail
          enumerable: false,
          get: function () {
            return this._writableState.highWaterMark;
          }
        });

        // if we're already writing something, then just put this
        // in the queue, and wait our turn.  Otherwise, call _write
        // If we return false, then we need a drain event, so set that flag.
        function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
          if (!isBuf) {
            var newChunk = decodeChunk(state, chunk, encoding);
            if (chunk !== newChunk) {
              isBuf = true;
              encoding = 'buffer';
              chunk = newChunk;
            }
          }
          var len = state.objectMode ? 1 : chunk.length;

          state.length += len;

          var ret = state.length < state.highWaterMark;
          // we must ensure that previous needDrain will not be reset to false.
          if (!ret) state.needDrain = true;

          if (state.writing || state.corked) {
            var last = state.lastBufferedRequest;
            state.lastBufferedRequest = {
              chunk: chunk,
              encoding: encoding,
              isBuf: isBuf,
              callback: cb,
              next: null
            };
            if (last) {
              last.next = state.lastBufferedRequest;
            } else {
              state.bufferedRequest = state.lastBufferedRequest;
            }
            state.bufferedRequestCount += 1;
          } else {
            doWrite(stream, state, false, len, chunk, encoding, cb);
          }

          return ret;
        }

        function doWrite(stream, state, writev, len, chunk, encoding, cb) {
          state.writelen = len;
          state.writecb = cb;
          state.writing = true;
          state.sync = true;
          if (writev) stream._writev(chunk, state.onwrite); else stream._write(chunk, encoding, state.onwrite);
          state.sync = false;
        }

        function onwriteError(stream, state, sync, er, cb) {
          --state.pendingcb;

          if (sync) {
            // defer the callback if we are being called synchronously
            // to avoid piling up things on the stack
            pna.nextTick(cb, er);
            // this can emit finish, and it will always happen
            // after error
            pna.nextTick(finishMaybe, stream, state);
            stream._writableState.errorEmitted = true;
            stream.emit('error', er);
          } else {
            // the caller expect this to happen before if
            // it is async
            cb(er);
            stream._writableState.errorEmitted = true;
            stream.emit('error', er);
            // this can emit finish, but finish must
            // always follow error
            finishMaybe(stream, state);
          }
        }

        function onwriteStateUpdate(state) {
          state.writing = false;
          state.writecb = null;
          state.length -= state.writelen;
          state.writelen = 0;
        }

        function onwrite(stream, er) {
          var state = stream._writableState;
          var sync = state.sync;
          var cb = state.writecb;

          onwriteStateUpdate(state);

          if (er) onwriteError(stream, state, sync, er, cb); else {
            // Check if we're actually ready to finish, but don't emit yet
            var finished = needFinish(state);

            if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
              clearBuffer(stream, state);
            }

            if (sync) {
              /*<replacement>*/
              asyncWrite(afterWrite, stream, state, finished, cb);
              /*</replacement>*/
            } else {
              afterWrite(stream, state, finished, cb);
            }
          }
        }

        function afterWrite(stream, state, finished, cb) {
          if (!finished) onwriteDrain(stream, state);
          state.pendingcb--;
          cb();
          finishMaybe(stream, state);
        }

        // Must force callback to be called on nextTick, so that we don't
        // emit 'drain' before the write() consumer gets the 'false' return
        // value, and has a chance to attach a 'drain' listener.
        function onwriteDrain(stream, state) {
          if (state.length === 0 && state.needDrain) {
            state.needDrain = false;
            stream.emit('drain');
          }
        }

        // if there's something in the buffer waiting, then process it
        function clearBuffer(stream, state) {
          state.bufferProcessing = true;
          var entry = state.bufferedRequest;

          if (stream._writev && entry && entry.next) {
            // Fast case, write everything using _writev()
            var l = state.bufferedRequestCount;
            var buffer = new Array(l);
            var holder = state.corkedRequestsFree;
            holder.entry = entry;

            var count = 0;
            var allBuffers = true;
            while (entry) {
              buffer[count] = entry;
              if (!entry.isBuf) allBuffers = false;
              entry = entry.next;
              count += 1;
            }
            buffer.allBuffers = allBuffers;

            doWrite(stream, state, true, state.length, buffer, '', holder.finish);

            // doWrite is almost always async, defer these to save a bit of time
            // as the hot path ends with doWrite
            state.pendingcb++;
            state.lastBufferedRequest = null;
            if (holder.next) {
              state.corkedRequestsFree = holder.next;
              holder.next = null;
            } else {
              state.corkedRequestsFree = new CorkedRequest(state);
            }
            state.bufferedRequestCount = 0;
          } else {
            // Slow case, write chunks one-by-one
            while (entry) {
              var chunk = entry.chunk;
              var encoding = entry.encoding;
              var cb = entry.callback;
              var len = state.objectMode ? 1 : chunk.length;

              doWrite(stream, state, false, len, chunk, encoding, cb);
              entry = entry.next;
              state.bufferedRequestCount--;
              // if we didn't call the onwrite immediately, then
              // it means that we need to wait until it does.
              // also, that means that the chunk and cb are currently
              // being processed, so move the buffer counter past them.
              if (state.writing) {
                break;
              }
            }

            if (entry === null) state.lastBufferedRequest = null;
          }

          state.bufferedRequest = entry;
          state.bufferProcessing = false;
        }

        Writable.prototype._write = function (chunk, encoding, cb) {
          cb(new Error('_write() is not implemented'));
        };

        Writable.prototype._writev = null;

        Writable.prototype.end = function (chunk, encoding, cb) {
          var state = this._writableState;

          if (typeof chunk === 'function') {
            cb = chunk;
            chunk = null;
            encoding = null;
          } else if (typeof encoding === 'function') {
            cb = encoding;
            encoding = null;
          }

          if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);

          // .end() fully uncorks
          if (state.corked) {
            state.corked = 1;
            this.uncork();
          }

          // ignore unnecessary end() calls.
          if (!state.ending && !state.finished) endWritable(this, state, cb);
        };

        function needFinish(state) {
          return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
        }
        function callFinal(stream, state) {
          stream._final(function (err) {
            state.pendingcb--;
            if (err) {
              stream.emit('error', err);
            }
            state.prefinished = true;
            stream.emit('prefinish');
            finishMaybe(stream, state);
          });
        }
        function prefinish(stream, state) {
          if (!state.prefinished && !state.finalCalled) {
            if (typeof stream._final === 'function') {
              state.pendingcb++;
              state.finalCalled = true;
              pna.nextTick(callFinal, stream, state);
            } else {
              state.prefinished = true;
              stream.emit('prefinish');
            }
          }
        }

        function finishMaybe(stream, state) {
          var need = needFinish(state);
          if (need) {
            prefinish(stream, state);
            if (state.pendingcb === 0) {
              state.finished = true;
              stream.emit('finish');
            }
          }
          return need;
        }

        function endWritable(stream, state, cb) {
          state.ending = true;
          finishMaybe(stream, state);
          if (cb) {
            if (state.finished) pna.nextTick(cb); else stream.once('finish', cb);
          }
          state.ended = true;
          stream.writable = false;
        }

        function onCorkedFinish(corkReq, state, err) {
          var entry = corkReq.entry;
          corkReq.entry = null;
          while (entry) {
            var cb = entry.callback;
            state.pendingcb--;
            cb(err);
            entry = entry.next;
          }
          if (state.corkedRequestsFree) {
            state.corkedRequestsFree.next = corkReq;
          } else {
            state.corkedRequestsFree = corkReq;
          }
        }

        Object.defineProperty(Writable.prototype, 'destroyed', {
          get: function () {
            if (this._writableState === undefined) {
              return false;
            }
            return this._writableState.destroyed;
          },
          set: function (value) {
            // we ignore the value if the stream
            // has not been initialized yet
            if (!this._writableState) {
              return;
            }

            // backward compatibility, the user is explicitly
            // managing destroyed
            this._writableState.destroyed = value;
          }
        });

        Writable.prototype.destroy = destroyImpl.destroy;
        Writable.prototype._undestroy = destroyImpl.undestroy;
        Writable.prototype._destroy = function (err, cb) {
          this.end();
          cb(err);
        };
      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}, require("timers").setImmediate)
    }, { "./_stream_duplex": 106, "./internal/streams/destroy": 112, "./internal/streams/stream": 113, "_process": 100, "core-util-is": 13, "inherits": 88, "process-nextick-args": 99, "safe-buffer": 118, "timers": 120, "util-deprecate": 134 }], 111: [function (require, module, exports) {
      'use strict';

      function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

      var Buffer = require('safe-buffer').Buffer;
      var util = require('util');

      function copyBuffer(src, target, offset) {
        src.copy(target, offset);
      }

      module.exports = function () {
        function BufferList() {
          _classCallCheck(this, BufferList);

          this.head = null;
          this.tail = null;
          this.length = 0;
        }

        BufferList.prototype.push = function push(v) {
          var entry = { data: v, next: null };
          if (this.length > 0) this.tail.next = entry; else this.head = entry;
          this.tail = entry;
          ++this.length;
        };

        BufferList.prototype.unshift = function unshift(v) {
          var entry = { data: v, next: this.head };
          if (this.length === 0) this.tail = entry;
          this.head = entry;
          ++this.length;
        };

        BufferList.prototype.shift = function shift() {
          if (this.length === 0) return;
          var ret = this.head.data;
          if (this.length === 1) this.head = this.tail = null; else this.head = this.head.next;
          --this.length;
          return ret;
        };

        BufferList.prototype.clear = function clear() {
          this.head = this.tail = null;
          this.length = 0;
        };

        BufferList.prototype.join = function join(s) {
          if (this.length === 0) return '';
          var p = this.head;
          var ret = '' + p.data;
          while (p = p.next) {
            ret += s + p.data;
          } return ret;
        };

        BufferList.prototype.concat = function concat(n) {
          if (this.length === 0) return Buffer.alloc(0);
          if (this.length === 1) return this.head.data;
          var ret = Buffer.allocUnsafe(n >>> 0);
          var p = this.head;
          var i = 0;
          while (p) {
            copyBuffer(p.data, ret, i);
            i += p.data.length;
            p = p.next;
          }
          return ret;
        };

        return BufferList;
      }();

      if (util && util.inspect && util.inspect.custom) {
        module.exports.prototype[util.inspect.custom] = function () {
          var obj = util.inspect({ length: this.length });
          return this.constructor.name + ' ' + obj;
        };
      }
    }, { "safe-buffer": 118, "util": 11 }], 112: [function (require, module, exports) {
      'use strict';

      /*<replacement>*/

      var pna = require('process-nextick-args');
      /*</replacement>*/

      // undocumented cb() API, needed for core, not for public API
      function destroy(err, cb) {
        var _this = this;

        var readableDestroyed = this._readableState && this._readableState.destroyed;
        var writableDestroyed = this._writableState && this._writableState.destroyed;

        if (readableDestroyed || writableDestroyed) {
          if (cb) {
            cb(err);
          } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
            pna.nextTick(emitErrorNT, this, err);
          }
          return this;
        }

        // we set destroyed to true before firing error callbacks in order
        // to make it re-entrance safe in case destroy() is called within callbacks

        if (this._readableState) {
          this._readableState.destroyed = true;
        }

        // if this is a duplex stream mark the writable part as destroyed as well
        if (this._writableState) {
          this._writableState.destroyed = true;
        }

        this._destroy(err || null, function (err) {
          if (!cb && err) {
            pna.nextTick(emitErrorNT, _this, err);
            if (_this._writableState) {
              _this._writableState.errorEmitted = true;
            }
          } else if (cb) {
            cb(err);
          }
        });

        return this;
      }

      function undestroy() {
        if (this._readableState) {
          this._readableState.destroyed = false;
          this._readableState.reading = false;
          this._readableState.ended = false;
          this._readableState.endEmitted = false;
        }

        if (this._writableState) {
          this._writableState.destroyed = false;
          this._writableState.ended = false;
          this._writableState.ending = false;
          this._writableState.finished = false;
          this._writableState.errorEmitted = false;
        }
      }

      function emitErrorNT(self, err) {
        self.emit('error', err);
      }

      module.exports = {
        destroy: destroy,
        undestroy: undestroy
      };
    }, { "process-nextick-args": 99 }], 113: [function (require, module, exports) {
      module.exports = require('events').EventEmitter;

    }, { "events": 83 }], 114: [function (require, module, exports) {
      var toString = {}.toString;

      module.exports = Array.isArray || function (arr) {
        return toString.call(arr) == '[object Array]';
      };

    }, {}], 115: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      /*<replacement>*/

      var Buffer = require('safe-buffer').Buffer;
      /*</replacement>*/

      var isEncoding = Buffer.isEncoding || function (encoding) {
        encoding = '' + encoding;
        switch (encoding && encoding.toLowerCase()) {
          case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw':
            return true;
          default:
            return false;
        }
      };

      function _normalizeEncoding(enc) {
        if (!enc) return 'utf8';
        var retried;
        while (true) {
          switch (enc) {
            case 'utf8':
            case 'utf-8':
              return 'utf8';
            case 'ucs2':
            case 'ucs-2':
            case 'utf16le':
            case 'utf-16le':
              return 'utf16le';
            case 'latin1':
            case 'binary':
              return 'latin1';
            case 'base64':
            case 'ascii':
            case 'hex':
              return enc;
            default:
              if (retried) return; // undefined
              enc = ('' + enc).toLowerCase();
              retried = true;
          }
        }
      };

      // Do not cache `Buffer.isEncoding` when checking encoding names as some
      // modules monkey-patch it to support additional encodings
      function normalizeEncoding(enc) {
        var nenc = _normalizeEncoding(enc);
        if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
        return nenc || enc;
      }

      // StringDecoder provides an interface for efficiently splitting a series of
      // buffers into a series of JS strings without breaking apart multi-byte
      // characters.
      exports.StringDecoder = StringDecoder;
      function StringDecoder(encoding) {
        this.encoding = normalizeEncoding(encoding);
        var nb;
        switch (this.encoding) {
          case 'utf16le':
            this.text = utf16Text;
            this.end = utf16End;
            nb = 4;
            break;
          case 'utf8':
            this.fillLast = utf8FillLast;
            nb = 4;
            break;
          case 'base64':
            this.text = base64Text;
            this.end = base64End;
            nb = 3;
            break;
          default:
            this.write = simpleWrite;
            this.end = simpleEnd;
            return;
        }
        this.lastNeed = 0;
        this.lastTotal = 0;
        this.lastChar = Buffer.allocUnsafe(nb);
      }

      StringDecoder.prototype.write = function (buf) {
        if (buf.length === 0) return '';
        var r;
        var i;
        if (this.lastNeed) {
          r = this.fillLast(buf);
          if (r === undefined) return '';
          i = this.lastNeed;
          this.lastNeed = 0;
        } else {
          i = 0;
        }
        if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
        return r || '';
      };

      StringDecoder.prototype.end = utf8End;

      // Returns only complete characters in a Buffer
      StringDecoder.prototype.text = utf8Text;

      // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
      StringDecoder.prototype.fillLast = function (buf) {
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
        this.lastNeed -= buf.length;
      };

      // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
      // continuation byte. If an invalid byte is detected, -2 is returned.
      function utf8CheckByte(byte) {
        if (byte <= 0x7F) return 0; else if (byte >> 5 === 0x06) return 2; else if (byte >> 4 === 0x0E) return 3; else if (byte >> 3 === 0x1E) return 4;
        return byte >> 6 === 0x02 ? -1 : -2;
      }

      // Checks at most 3 bytes at the end of a Buffer in order to detect an
      // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
      // needed to complete the UTF-8 character (if applicable) are returned.
      function utf8CheckIncomplete(self, buf, i) {
        var j = buf.length - 1;
        if (j < i) return 0;
        var nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self.lastNeed = nb - 1;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self.lastNeed = nb - 2;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) {
            if (nb === 2) nb = 0; else self.lastNeed = nb - 3;
          }
          return nb;
        }
        return 0;
      }

      // Validates as many continuation bytes for a multi-byte UTF-8 character as
      // needed or are available. If we see a non-continuation byte where we expect
      // one, we "replace" the validated continuation bytes we've seen so far with
      // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
      // behavior. The continuation byte check is included three times in the case
      // where all of the continuation bytes for a character exist in the same buffer.
      // It is also done this way as a slight performance increase instead of using a
      // loop.
      function utf8CheckExtraBytes(self, buf, p) {
        if ((buf[0] & 0xC0) !== 0x80) {
          self.lastNeed = 0;
          return '\ufffd';
        }
        if (self.lastNeed > 1 && buf.length > 1) {
          if ((buf[1] & 0xC0) !== 0x80) {
            self.lastNeed = 1;
            return '\ufffd';
          }
          if (self.lastNeed > 2 && buf.length > 2) {
            if ((buf[2] & 0xC0) !== 0x80) {
              self.lastNeed = 2;
              return '\ufffd';
            }
          }
        }
      }

      // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
      function utf8FillLast(buf) {
        var p = this.lastTotal - this.lastNeed;
        var r = utf8CheckExtraBytes(this, buf, p);
        if (r !== undefined) return r;
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, p, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, p, 0, buf.length);
        this.lastNeed -= buf.length;
      }

      // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
      // partial character, the character's bytes are buffered until the required
      // number of bytes are available.
      function utf8Text(buf, i) {
        var total = utf8CheckIncomplete(this, buf, i);
        if (!this.lastNeed) return buf.toString('utf8', i);
        this.lastTotal = total;
        var end = buf.length - (total - this.lastNeed);
        buf.copy(this.lastChar, 0, end);
        return buf.toString('utf8', i, end);
      }

      // For UTF-8, a replacement character is added when ending on a partial
      // character.
      function utf8End(buf) {
        var r = buf && buf.length ? this.write(buf) : '';
        if (this.lastNeed) return r + '\ufffd';
        return r;
      }

      // UTF-16LE typically needs two bytes per character, but even if we have an even
      // number of bytes available, we need to check if we end on a leading/high
      // surrogate. In that case, we need to wait for the next two bytes in order to
      // decode the last character properly.
      function utf16Text(buf, i) {
        if ((buf.length - i) % 2 === 0) {
          var r = buf.toString('utf16le', i);
          if (r) {
            var c = r.charCodeAt(r.length - 1);
            if (c >= 0xD800 && c <= 0xDBFF) {
              this.lastNeed = 2;
              this.lastTotal = 4;
              this.lastChar[0] = buf[buf.length - 2];
              this.lastChar[1] = buf[buf.length - 1];
              return r.slice(0, -1);
            }
          }
          return r;
        }
        this.lastNeed = 1;
        this.lastTotal = 2;
        this.lastChar[0] = buf[buf.length - 1];
        return buf.toString('utf16le', i, buf.length - 1);
      }

      // For UTF-16LE we do not explicitly append special replacement characters if we
      // end on a partial character, we simply let v8 handle that.
      function utf16End(buf) {
        var r = buf && buf.length ? this.write(buf) : '';
        if (this.lastNeed) {
          var end = this.lastTotal - this.lastNeed;
          return r + this.lastChar.toString('utf16le', 0, end);
        }
        return r;
      }

      function base64Text(buf, i) {
        var n = (buf.length - i) % 3;
        if (n === 0) return buf.toString('base64', i);
        this.lastNeed = 3 - n;
        this.lastTotal = 3;
        if (n === 1) {
          this.lastChar[0] = buf[buf.length - 1];
        } else {
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
        }
        return buf.toString('base64', i, buf.length - n);
      }

      function base64End(buf) {
        var r = buf && buf.length ? this.write(buf) : '';
        if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
        return r;
      }

      // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
      function simpleWrite(buf) {
        return buf.toString(this.encoding);
      }

      function simpleEnd(buf) {
        return buf && buf.length ? this.write(buf) : '';
      }
    }, { "safe-buffer": 118 }], 116: [function (require, module, exports) {
      exports = module.exports = require('./lib/_stream_readable.js');
      exports.Stream = exports;
      exports.Readable = exports;
      exports.Writable = require('./lib/_stream_writable.js');
      exports.Duplex = require('./lib/_stream_duplex.js');
      exports.Transform = require('./lib/_stream_transform.js');
      exports.PassThrough = require('./lib/_stream_passthrough.js');

    }, { "./lib/_stream_duplex.js": 106, "./lib/_stream_passthrough.js": 107, "./lib/_stream_readable.js": 108, "./lib/_stream_transform.js": 109, "./lib/_stream_writable.js": 110 }], 117: [function (require, module, exports) {
      'use strict'

      function ReInterval(callback, interval, args) {
        var self = this;

        this._callback = callback;
        this._args = args;

        this._interval = setInterval(callback, interval, this._args);

        this.reschedule = function (interval) {
          // if no interval entered, use the interval passed in on creation
          if (!interval)
            interval = self._interval;

          if (self._interval)
            clearInterval(self._interval);
          self._interval = setInterval(self._callback, interval, self._args);
        };

        this.clear = function () {
          if (self._interval) {
            clearInterval(self._interval);
            self._interval = undefined;
          }
        };

        this.destroy = function () {
          if (self._interval) {
            clearInterval(self._interval);
          }
          self._callback = undefined;
          self._interval = undefined;
          self._args = undefined;
        };
      }

      function reInterval() {
        if (typeof arguments[0] !== 'function')
          throw new Error('callback needed');
        if (typeof arguments[1] !== 'number')
          throw new Error('interval needed');

        var args;

        if (arguments.length > 0) {
          args = new Array(arguments.length - 2);

          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i + 2];
          }
        }

        return new ReInterval(arguments[0], arguments[1], args);
      }

      module.exports = reInterval;

    }, {}], 118: [function (require, module, exports) {
      /* eslint-disable node/no-deprecated-api */
      var buffer = require('buffer')
      var Buffer = buffer.Buffer

      // alternative to using Object.keys for old browsers
      function copyProps(src, dst) {
        for (var key in src) {
          dst[key] = src[key]
        }
      }
      if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
        module.exports = buffer
      } else {
        // Copy properties from require('buffer')
        copyProps(buffer, exports)
        exports.Buffer = SafeBuffer
      }

      function SafeBuffer(arg, encodingOrOffset, length) {
        return Buffer(arg, encodingOrOffset, length)
      }

      // Copy static methods from Buffer
      copyProps(Buffer, SafeBuffer)

      SafeBuffer.from = function (arg, encodingOrOffset, length) {
        if (typeof arg === 'number') {
          throw new TypeError('Argument must not be a number')
        }
        return Buffer(arg, encodingOrOffset, length)
      }

      SafeBuffer.alloc = function (size, fill, encoding) {
        if (typeof size !== 'number') {
          throw new TypeError('Argument must be a number')
        }
        var buf = Buffer(size)
        if (fill !== undefined) {
          if (typeof encoding === 'string') {
            buf.fill(fill, encoding)
          } else {
            buf.fill(fill)
          }
        } else {
          buf.fill(0)
        }
        return buf
      }

      SafeBuffer.allocUnsafe = function (size) {
        if (typeof size !== 'number') {
          throw new TypeError('Argument must be a number')
        }
        return Buffer(size)
      }

      SafeBuffer.allocUnsafeSlow = function (size) {
        if (typeof size !== 'number') {
          throw new TypeError('Argument must be a number')
        }
        return buffer.SlowBuffer(size)
      }

    }, { "buffer": 12 }], 119: [function (require, module, exports) {
      module.exports = shift

      function shift(stream) {
        var rs = stream._readableState
        if (!rs) return null
        return (rs.objectMode || typeof stream._duplexState === 'number') ? stream.read() : stream.read(getStateLength(rs))
      }

      function getStateLength(state) {
        if (state.buffer.length) {
          // Since node 6.3.0 state.buffer is a BufferList not an array
          if (state.buffer.head) {
            return state.buffer.head.data.length
          }

          return state.buffer[0].length
        }

        return state.length
      }

    }, {}], 120: [function (require, module, exports) {
      (function (setImmediate, clearImmediate) {
        var nextTick = require('process/browser.js').nextTick;
        var apply = Function.prototype.apply;
        var slice = Array.prototype.slice;
        var immediateIds = {};
        var nextImmediateId = 0;

        // DOM APIs, for completeness

        exports.setTimeout = function () {
          return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
        };
        exports.setInterval = function () {
          return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
        };
        exports.clearTimeout =
          exports.clearInterval = function (timeout) { timeout.close(); };

        function Timeout(id, clearFn) {
          this._id = id;
          this._clearFn = clearFn;
        }
        Timeout.prototype.unref = Timeout.prototype.ref = function () { };
        Timeout.prototype.close = function () {
          this._clearFn.call(window, this._id);
        };

        // Does not start the time, just sets up the members needed.
        exports.enroll = function (item, msecs) {
          clearTimeout(item._idleTimeoutId);
          item._idleTimeout = msecs;
        };

        exports.unenroll = function (item) {
          clearTimeout(item._idleTimeoutId);
          item._idleTimeout = -1;
        };

        exports._unrefActive = exports.active = function (item) {
          clearTimeout(item._idleTimeoutId);

          var msecs = item._idleTimeout;
          if (msecs >= 0) {
            item._idleTimeoutId = setTimeout(function onTimeout() {
              if (item._onTimeout)
                item._onTimeout();
            }, msecs);
          }
        };

        // That's not how node.js implements it but the exposed api is the same.
        exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function (fn) {
          var id = nextImmediateId++;
          var args = arguments.length < 2 ? false : slice.call(arguments, 1);

          immediateIds[id] = true;

          nextTick(function onNextTick() {
            if (immediateIds[id]) {
              // fn.call() is faster so we optimize for the common use-case
              // @see http://jsperf.com/call-apply-segu
              if (args) {
                fn.apply(null, args);
              } else {
                fn.call(null);
              }
              // Prevent ids from leaking
              exports.clearImmediate(id);
            }
          });

          return id;
        };

        exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function (id) {
          delete immediateIds[id];
        };
      }).call(this, require("timers").setImmediate, require("timers").clearImmediate)
    }, { "process/browser.js": 100, "timers": 120 }], 121: [function (require, module, exports) {
      "use strict";

      var isPrototype = require("../prototype/is");

      module.exports = function (value) {
        if (typeof value !== "function") return false;

        if (!hasOwnProperty.call(value, "length")) return false;

        try {
          if (typeof value.length !== "number") return false;
          if (typeof value.call !== "function") return false;
          if (typeof value.apply !== "function") return false;
        } catch (error) {
          return false;
        }

        return !isPrototype(value);
      };

    }, { "../prototype/is": 128 }], 122: [function (require, module, exports) {
      "use strict";

      var isValue = require("../value/is")
        , isObject = require("../object/is")
        , stringCoerce = require("../string/coerce")
        , toShortString = require("./to-short-string");

      var resolveMessage = function (message, value) {
        return message.replace("%v", toShortString(value));
      };

      module.exports = function (value, defaultMessage, inputOptions) {
        if (!isObject(inputOptions)) throw new TypeError(resolveMessage(defaultMessage, value));
        if (!isValue(value)) {
          if ("default" in inputOptions) return inputOptions["default"];
          if (inputOptions.isOptional) return null;
        }
        var errorMessage = stringCoerce(inputOptions.errorMessage);
        if (!isValue(errorMessage)) errorMessage = defaultMessage;
        throw new TypeError(resolveMessage(errorMessage, value));
      };

    }, { "../object/is": 125, "../string/coerce": 129, "../value/is": 131, "./to-short-string": 124 }], 123: [function (require, module, exports) {
      "use strict";

      module.exports = function (value) {
        try {
          return value.toString();
        } catch (error) {
          try { return String(value); }
          catch (error2) { return null; }
        }
      };

    }, {}], 124: [function (require, module, exports) {
      "use strict";

      var safeToString = require("./safe-to-string");

      var reNewLine = /[\n\r\u2028\u2029]/g;

      module.exports = function (value) {
        var string = safeToString(value);
        if (string === null) return "<Non-coercible to string value>";
        // Trim if too long
        if (string.length > 100) string = string.slice(0, 99) + "…";
        // Replace eventual new lines
        string = string.replace(reNewLine, function (char) {
          switch (char) {
            case "\n":
              return "\\n";
            case "\r":
              return "\\r";
            case "\u2028":
              return "\\u2028";
            case "\u2029":
              return "\\u2029";
            /* istanbul ignore next */
            default:
              throw new Error("Unexpected character");
          }
        });
        return string;
      };

    }, { "./safe-to-string": 123 }], 125: [function (require, module, exports) {
      "use strict";

      var isValue = require("../value/is");

      // prettier-ignore
      var possibleTypes = { "object": true, "function": true, "undefined": true /* document.all */ };

      module.exports = function (value) {
        if (!isValue(value)) return false;
        return hasOwnProperty.call(possibleTypes, typeof value);
      };

    }, { "../value/is": 131 }], 126: [function (require, module, exports) {
      "use strict";

      var resolveException = require("../lib/resolve-exception")
        , is = require("./is");

      module.exports = function (value/*, options*/) {
        if (is(value)) return value;
        return resolveException(value, "%v is not a plain function", arguments[1]);
      };

    }, { "../lib/resolve-exception": 122, "./is": 127 }], 127: [function (require, module, exports) {
      "use strict";

      var isFunction = require("../function/is");

      var classRe = /^\s*class[\s{/}]/, functionToString = Function.prototype.toString;

      module.exports = function (value) {
        if (!isFunction(value)) return false;
        if (classRe.test(functionToString.call(value))) return false;
        return true;
      };

    }, { "../function/is": 121 }], 128: [function (require, module, exports) {
      "use strict";

      var isObject = require("../object/is");

      module.exports = function (value) {
        if (!isObject(value)) return false;
        try {
          if (!value.constructor) return false;
          return value.constructor.prototype === value;
        } catch (error) {
          return false;
        }
      };

    }, { "../object/is": 125 }], 129: [function (require, module, exports) {
      "use strict";

      var isValue = require("../value/is")
        , isObject = require("../object/is");

      var objectToString = Object.prototype.toString;

      module.exports = function (value) {
        if (!isValue(value)) return null;
        if (isObject(value)) {
          // Reject Object.prototype.toString coercion
          var valueToString = value.toString;
          if (typeof valueToString !== "function") return null;
          if (valueToString === objectToString) return null;
          // Note: It can be object coming from other realm, still as there's no ES3 and CSP compliant
          // way to resolve its realm's Object.prototype.toString it's left as not addressed edge case
        }
        try {
          return "" + value; // Ensure implicit coercion
        } catch (error) {
          return null;
        }
      };

    }, { "../object/is": 125, "../value/is": 131 }], 130: [function (require, module, exports) {
      "use strict";

      var resolveException = require("../lib/resolve-exception")
        , is = require("./is");

      module.exports = function (value/*, options*/) {
        if (is(value)) return value;
        return resolveException(value, "Cannot use %v", arguments[1]);
      };

    }, { "../lib/resolve-exception": 122, "./is": 131 }], 131: [function (require, module, exports) {
      "use strict";

      // ES3 safe
      var _undefined = void 0;

      module.exports = function (value) { return value !== _undefined && value !== null; };

    }, {}], 132: [function (require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      var punycode = require('punycode');
      var util = require('./util');

      exports.parse = urlParse;
      exports.resolve = urlResolve;
      exports.resolveObject = urlResolveObject;
      exports.format = urlFormat;

      exports.Url = Url;

      function Url() {
        this.protocol = null;
        this.slashes = null;
        this.auth = null;
        this.host = null;
        this.port = null;
        this.hostname = null;
        this.hash = null;
        this.search = null;
        this.query = null;
        this.pathname = null;
        this.path = null;
        this.href = null;
      }

      // Reference: RFC 3986, RFC 1808, RFC 2396

      // define these here so at least they only have to be
      // compiled once on the first module load.
      var protocolPattern = /^([a-z0-9.+-]+:)/i,
        portPattern = /:[0-9]*$/,

        // Special case for a simple path URL
        simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,

        // RFC 2396: characters reserved for delimiting URLs.
        // We actually just auto-escape these.
        delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],

        // RFC 2396: characters not allowed for various reasons.
        unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),

        // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
        autoEscape = ['\''].concat(unwise),
        // Characters that are never ever allowed in a hostname.
        // Note that any invalid chars are also handled, but these
        // are the ones that are *expected* to be seen, so we fast-path
        // them.
        nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
        hostEndingChars = ['/', '?', '#'],
        hostnameMaxLen = 255,
        hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
        hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
        // protocols that can allow "unsafe" and "unwise" chars.
        unsafeProtocol = {
          'javascript': true,
          'javascript:': true
        },
        // protocols that never have a hostname.
        hostlessProtocol = {
          'javascript': true,
          'javascript:': true
        },
        // protocols that always contain a // bit.
        slashedProtocol = {
          'http': true,
          'https': true,
          'ftp': true,
          'gopher': true,
          'file': true,
          'http:': true,
          'https:': true,
          'ftp:': true,
          'gopher:': true,
          'file:': true
        },
        querystring = require('querystring');

      function urlParse(url, parseQueryString, slashesDenoteHost) {
        if (url && util.isObject(url) && url instanceof Url) return url;

        var u = new Url;
        u.parse(url, parseQueryString, slashesDenoteHost);
        return u;
      }

      Url.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {
        if (!util.isString(url)) {
          throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
        }

        // Copy chrome, IE, opera backslash-handling behavior.
        // Back slashes before the query string get converted to forward slashes
        // See: https://code.google.com/p/chromium/issues/detail?id=25916
        var queryIndex = url.indexOf('?'),
          splitter =
            (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
          uSplit = url.split(splitter),
          slashRegex = /\\/g;
        uSplit[0] = uSplit[0].replace(slashRegex, '/');
        url = uSplit.join(splitter);

        var rest = url;

        // trim before proceeding.
        // This is to support parse stuff like "  http://foo.com  \n"
        rest = rest.trim();

        if (!slashesDenoteHost && url.split('#').length === 1) {
          // Try fast path regexp
          var simplePath = simplePathPattern.exec(rest);
          if (simplePath) {
            this.path = rest;
            this.href = rest;
            this.pathname = simplePath[1];
            if (simplePath[2]) {
              this.search = simplePath[2];
              if (parseQueryString) {
                this.query = querystring.parse(this.search.substr(1));
              } else {
                this.query = this.search.substr(1);
              }
            } else if (parseQueryString) {
              this.search = '';
              this.query = {};
            }
            return this;
          }
        }

        var proto = protocolPattern.exec(rest);
        if (proto) {
          proto = proto[0];
          var lowerProto = proto.toLowerCase();
          this.protocol = lowerProto;
          rest = rest.substr(proto.length);
        }

        // figure out if it's got a host
        // user@server is *always* interpreted as a hostname, and url
        // resolution will treat //foo/bar as host=foo,path=bar because that's
        // how the browser resolves relative URLs.
        if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
          var slashes = rest.substr(0, 2) === '//';
          if (slashes && !(proto && hostlessProtocol[proto])) {
            rest = rest.substr(2);
            this.slashes = true;
          }
        }

        if (!hostlessProtocol[proto] &&
          (slashes || (proto && !slashedProtocol[proto]))) {

          // there's a hostname.
          // the first instance of /, ?, ;, or # ends the host.
          //
          // If there is an @ in the hostname, then non-host chars *are* allowed
          // to the left of the last @ sign, unless some host-ending character
          // comes *before* the @-sign.
          // URLs are obnoxious.
          //
          // ex:
          // http://a@b@c/ => user:a@b host:c
          // http://a@b?@c => user:a host:c path:/?@c

          // v0.12 TODO(isaacs): This is not quite how Chrome does things.
          // Review our test case against browsers more comprehensively.

          // find the first instance of any hostEndingChars
          var hostEnd = -1;
          for (var i = 0; i < hostEndingChars.length; i++) {
            var hec = rest.indexOf(hostEndingChars[i]);
            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
              hostEnd = hec;
          }

          // at this point, either we have an explicit point where the
          // auth portion cannot go past, or the last @ char is the decider.
          var auth, atSign;
          if (hostEnd === -1) {
            // atSign can be anywhere.
            atSign = rest.lastIndexOf('@');
          } else {
            // atSign must be in auth portion.
            // http://a@b/c@d => host:b auth:a path:/c@d
            atSign = rest.lastIndexOf('@', hostEnd);
          }

          // Now we have a portion which is definitely the auth.
          // Pull that off.
          if (atSign !== -1) {
            auth = rest.slice(0, atSign);
            rest = rest.slice(atSign + 1);
            this.auth = decodeURIComponent(auth);
          }

          // the host is the remaining to the left of the first non-host char
          hostEnd = -1;
          for (var i = 0; i < nonHostChars.length; i++) {
            var hec = rest.indexOf(nonHostChars[i]);
            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
              hostEnd = hec;
          }
          // if we still have not hit it, then the entire thing is a host.
          if (hostEnd === -1)
            hostEnd = rest.length;

          this.host = rest.slice(0, hostEnd);
          rest = rest.slice(hostEnd);

          // pull out port.
          this.parseHost();

          // we've indicated that there is a hostname,
          // so even if it's empty, it has to be present.
          this.hostname = this.hostname || '';

          // if hostname begins with [ and ends with ]
          // assume that it's an IPv6 address.
          var ipv6Hostname = this.hostname[0] === '[' &&
            this.hostname[this.hostname.length - 1] === ']';

          // validate a little.
          if (!ipv6Hostname) {
            var hostparts = this.hostname.split(/\./);
            for (var i = 0, l = hostparts.length; i < l; i++) {
              var part = hostparts[i];
              if (!part) continue;
              if (!part.match(hostnamePartPattern)) {
                var newpart = '';
                for (var j = 0, k = part.length; j < k; j++) {
                  if (part.charCodeAt(j) > 127) {
                    // we replace non-ASCII char with a temporary placeholder
                    // we need this to make sure size of hostname is not
                    // broken by replacing non-ASCII by nothing
                    newpart += 'x';
                  } else {
                    newpart += part[j];
                  }
                }
                // we test again with ASCII char only
                if (!newpart.match(hostnamePartPattern)) {
                  var validParts = hostparts.slice(0, i);
                  var notHost = hostparts.slice(i + 1);
                  var bit = part.match(hostnamePartStart);
                  if (bit) {
                    validParts.push(bit[1]);
                    notHost.unshift(bit[2]);
                  }
                  if (notHost.length) {
                    rest = '/' + notHost.join('.') + rest;
                  }
                  this.hostname = validParts.join('.');
                  break;
                }
              }
            }
          }

          if (this.hostname.length > hostnameMaxLen) {
            this.hostname = '';
          } else {
            // hostnames are always lower case.
            this.hostname = this.hostname.toLowerCase();
          }

          if (!ipv6Hostname) {
            // IDNA Support: Returns a punycoded representation of "domain".
            // It only converts parts of the domain name that
            // have non-ASCII characters, i.e. it doesn't matter if
            // you call it with a domain that already is ASCII-only.
            this.hostname = punycode.toASCII(this.hostname);
          }

          var p = this.port ? ':' + this.port : '';
          var h = this.hostname || '';
          this.host = h + p;
          this.href += this.host;

          // strip [ and ] from the hostname
          // the host field still retains them, though
          if (ipv6Hostname) {
            this.hostname = this.hostname.substr(1, this.hostname.length - 2);
            if (rest[0] !== '/') {
              rest = '/' + rest;
            }
          }
        }

        // now rest is set to the post-host stuff.
        // chop off any delim chars.
        if (!unsafeProtocol[lowerProto]) {

          // First, make 100% sure that any "autoEscape" chars get
          // escaped, even if encodeURIComponent doesn't think they
          // need to be.
          for (var i = 0, l = autoEscape.length; i < l; i++) {
            var ae = autoEscape[i];
            if (rest.indexOf(ae) === -1)
              continue;
            var esc = encodeURIComponent(ae);
            if (esc === ae) {
              esc = escape(ae);
            }
            rest = rest.split(ae).join(esc);
          }
        }


        // chop off from the tail first.
        var hash = rest.indexOf('#');
        if (hash !== -1) {
          // got a fragment string.
          this.hash = rest.substr(hash);
          rest = rest.slice(0, hash);
        }
        var qm = rest.indexOf('?');
        if (qm !== -1) {
          this.search = rest.substr(qm);
          this.query = rest.substr(qm + 1);
          if (parseQueryString) {
            this.query = querystring.parse(this.query);
          }
          rest = rest.slice(0, qm);
        } else if (parseQueryString) {
          // no query string, but parseQueryString still requested
          this.search = '';
          this.query = {};
        }
        if (rest) this.pathname = rest;
        if (slashedProtocol[lowerProto] &&
          this.hostname && !this.pathname) {
          this.pathname = '/';
        }

        //to support http.request
        if (this.pathname || this.search) {
          var p = this.pathname || '';
          var s = this.search || '';
          this.path = p + s;
        }

        // finally, reconstruct the href based on what has been validated.
        this.href = this.format();
        return this;
      };

      // format a parsed object into a url string
      function urlFormat(obj) {
        // ensure it's an object, and not a string url.
        // If it's an obj, this is a no-op.
        // this way, you can call url_format() on strings
        // to clean up potentially wonky urls.
        if (util.isString(obj)) obj = urlParse(obj);
        if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
        return obj.format();
      }

      Url.prototype.format = function () {
        var auth = this.auth || '';
        if (auth) {
          auth = encodeURIComponent(auth);
          auth = auth.replace(/%3A/i, ':');
          auth += '@';
        }

        var protocol = this.protocol || '',
          pathname = this.pathname || '',
          hash = this.hash || '',
          host = false,
          query = '';

        if (this.host) {
          host = auth + this.host;
        } else if (this.hostname) {
          host = auth + (this.hostname.indexOf(':') === -1 ?
            this.hostname :
            '[' + this.hostname + ']');
          if (this.port) {
            host += ':' + this.port;
          }
        }

        if (this.query &&
          util.isObject(this.query) &&
          Object.keys(this.query).length) {
          query = querystring.stringify(this.query);
        }

        var search = this.search || (query && ('?' + query)) || '';

        if (protocol && protocol.substr(-1) !== ':') protocol += ':';

        // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
        // unless they had them to begin with.
        if (this.slashes ||
          (!protocol || slashedProtocol[protocol]) && host !== false) {
          host = '//' + (host || '');
          if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
        } else if (!host) {
          host = '';
        }

        if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
        if (search && search.charAt(0) !== '?') search = '?' + search;

        pathname = pathname.replace(/[?#]/g, function (match) {
          return encodeURIComponent(match);
        });
        search = search.replace('#', '%23');

        return protocol + host + pathname + search + hash;
      };

      function urlResolve(source, relative) {
        return urlParse(source, false, true).resolve(relative);
      }

      Url.prototype.resolve = function (relative) {
        return this.resolveObject(urlParse(relative, false, true)).format();
      };

      function urlResolveObject(source, relative) {
        if (!source) return relative;
        return urlParse(source, false, true).resolveObject(relative);
      }

      Url.prototype.resolveObject = function (relative) {
        if (util.isString(relative)) {
          var rel = new Url();
          rel.parse(relative, false, true);
          relative = rel;
        }

        var result = new Url();
        var tkeys = Object.keys(this);
        for (var tk = 0; tk < tkeys.length; tk++) {
          var tkey = tkeys[tk];
          result[tkey] = this[tkey];
        }

        // hash is always overridden, no matter what.
        // even href="" will remove it.
        result.hash = relative.hash;

        // if the relative url is empty, then there's nothing left to do here.
        if (relative.href === '') {
          result.href = result.format();
          return result;
        }

        // hrefs like //foo/bar always cut to the protocol.
        if (relative.slashes && !relative.protocol) {
          // take everything except the protocol from relative
          var rkeys = Object.keys(relative);
          for (var rk = 0; rk < rkeys.length; rk++) {
            var rkey = rkeys[rk];
            if (rkey !== 'protocol')
              result[rkey] = relative[rkey];
          }

          //urlParse appends trailing / to urls like http://www.example.com
          if (slashedProtocol[result.protocol] &&
            result.hostname && !result.pathname) {
            result.path = result.pathname = '/';
          }

          result.href = result.format();
          return result;
        }

        if (relative.protocol && relative.protocol !== result.protocol) {
          // if it's a known url protocol, then changing
          // the protocol does weird things
          // first, if it's not file:, then we MUST have a host,
          // and if there was a path
          // to begin with, then we MUST have a path.
          // if it is file:, then the host is dropped,
          // because that's known to be hostless.
          // anything else is assumed to be absolute.
          if (!slashedProtocol[relative.protocol]) {
            var keys = Object.keys(relative);
            for (var v = 0; v < keys.length; v++) {
              var k = keys[v];
              result[k] = relative[k];
            }
            result.href = result.format();
            return result;
          }

          result.protocol = relative.protocol;
          if (!relative.host && !hostlessProtocol[relative.protocol]) {
            var relPath = (relative.pathname || '').split('/');
            while (relPath.length && !(relative.host = relPath.shift()));
            if (!relative.host) relative.host = '';
            if (!relative.hostname) relative.hostname = '';
            if (relPath[0] !== '') relPath.unshift('');
            if (relPath.length < 2) relPath.unshift('');
            result.pathname = relPath.join('/');
          } else {
            result.pathname = relative.pathname;
          }
          result.search = relative.search;
          result.query = relative.query;
          result.host = relative.host || '';
          result.auth = relative.auth;
          result.hostname = relative.hostname || relative.host;
          result.port = relative.port;
          // to support http.request
          if (result.pathname || result.search) {
            var p = result.pathname || '';
            var s = result.search || '';
            result.path = p + s;
          }
          result.slashes = result.slashes || relative.slashes;
          result.href = result.format();
          return result;
        }

        var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
          isRelAbs = (
            relative.host ||
            relative.pathname && relative.pathname.charAt(0) === '/'
          ),
          mustEndAbs = (isRelAbs || isSourceAbs ||
            (result.host && relative.pathname)),
          removeAllDots = mustEndAbs,
          srcPath = result.pathname && result.pathname.split('/') || [],
          relPath = relative.pathname && relative.pathname.split('/') || [],
          psychotic = result.protocol && !slashedProtocol[result.protocol];

        // if the url is a non-slashed url, then relative
        // links like ../.. should be able
        // to crawl up to the hostname, as well.  This is strange.
        // result.protocol has already been set by now.
        // Later on, put the first path part into the host field.
        if (psychotic) {
          result.hostname = '';
          result.port = null;
          if (result.host) {
            if (srcPath[0] === '') srcPath[0] = result.host;
            else srcPath.unshift(result.host);
          }
          result.host = '';
          if (relative.protocol) {
            relative.hostname = null;
            relative.port = null;
            if (relative.host) {
              if (relPath[0] === '') relPath[0] = relative.host;
              else relPath.unshift(relative.host);
            }
            relative.host = null;
          }
          mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
        }

        if (isRelAbs) {
          // it's absolute.
          result.host = (relative.host || relative.host === '') ?
            relative.host : result.host;
          result.hostname = (relative.hostname || relative.hostname === '') ?
            relative.hostname : result.hostname;
          result.search = relative.search;
          result.query = relative.query;
          srcPath = relPath;
          // fall through to the dot-handling below.
        } else if (relPath.length) {
          // it's relative
          // throw away the existing file, and take the new path instead.
          if (!srcPath) srcPath = [];
          srcPath.pop();
          srcPath = srcPath.concat(relPath);
          result.search = relative.search;
          result.query = relative.query;
        } else if (!util.isNullOrUndefined(relative.search)) {
          // just pull out the search.
          // like href='?foo'.
          // Put this after the other two cases because it simplifies the booleans
          if (psychotic) {
            result.hostname = result.host = srcPath.shift();
            //occationaly the auth can get stuck only in host
            //this especially happens in cases like
            //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
            var authInHost = result.host && result.host.indexOf('@') > 0 ?
              result.host.split('@') : false;
            if (authInHost) {
              result.auth = authInHost.shift();
              result.host = result.hostname = authInHost.shift();
            }
          }
          result.search = relative.search;
          result.query = relative.query;
          //to support http.request
          if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
            result.path = (result.pathname ? result.pathname : '') +
              (result.search ? result.search : '');
          }
          result.href = result.format();
          return result;
        }

        if (!srcPath.length) {
          // no path at all.  easy.
          // we've already handled the other stuff above.
          result.pathname = null;
          //to support http.request
          if (result.search) {
            result.path = '/' + result.search;
          } else {
            result.path = null;
          }
          result.href = result.format();
          return result;
        }

        // if a url ENDs in . or .., then it must get a trailing slash.
        // however, if it ends in anything else non-slashy,
        // then it must NOT get a trailing slash.
        var last = srcPath.slice(-1)[0];
        var hasTrailingSlash = (
          (result.host || relative.host || srcPath.length > 1) &&
          (last === '.' || last === '..') || last === '');

        // strip single dots, resolve double dots to parent dir
        // if the path tries to go above the root, `up` ends up > 0
        var up = 0;
        for (var i = srcPath.length; i >= 0; i--) {
          last = srcPath[i];
          if (last === '.') {
            srcPath.splice(i, 1);
          } else if (last === '..') {
            srcPath.splice(i, 1);
            up++;
          } else if (up) {
            srcPath.splice(i, 1);
            up--;
          }
        }

        // if the path is allowed to go above the root, restore leading ..s
        if (!mustEndAbs && !removeAllDots) {
          for (; up--; up) {
            srcPath.unshift('..');
          }
        }

        if (mustEndAbs && srcPath[0] !== '' &&
          (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
          srcPath.unshift('');
        }

        if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
          srcPath.push('');
        }

        var isAbsolute = srcPath[0] === '' ||
          (srcPath[0] && srcPath[0].charAt(0) === '/');

        // put the host back
        if (psychotic) {
          result.hostname = result.host = isAbsolute ? '' :
            srcPath.length ? srcPath.shift() : '';
          //occationaly the auth can get stuck only in host
          //this especially happens in cases like
          //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
          var authInHost = result.host && result.host.indexOf('@') > 0 ?
            result.host.split('@') : false;
          if (authInHost) {
            result.auth = authInHost.shift();
            result.host = result.hostname = authInHost.shift();
          }
        }

        mustEndAbs = mustEndAbs || (result.host && srcPath.length);

        if (mustEndAbs && !isAbsolute) {
          srcPath.unshift('');
        }

        if (!srcPath.length) {
          result.pathname = null;
          result.path = null;
        } else {
          result.pathname = srcPath.join('/');
        }

        //to support request.http
        if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
          result.path = (result.pathname ? result.pathname : '') +
            (result.search ? result.search : '');
        }
        result.auth = relative.auth || result.auth;
        result.slashes = result.slashes || relative.slashes;
        result.href = result.format();
        return result;
      };

      Url.prototype.parseHost = function () {
        var host = this.host;
        var port = portPattern.exec(host);
        if (port) {
          port = port[0];
          if (port !== ':') {
            this.port = port.substr(1);
          }
          host = host.substr(0, host.length - port.length);
        }
        if (host) this.hostname = host;
      };

    }, { "./util": 133, "punycode": 101, "querystring": 104 }], 133: [function (require, module, exports) {
      'use strict';

      module.exports = {
        isString: function (arg) {
          return typeof (arg) === 'string';
        },
        isObject: function (arg) {
          return typeof (arg) === 'object' && arg !== null;
        },
        isNull: function (arg) {
          return arg === null;
        },
        isNullOrUndefined: function (arg) {
          return arg == null;
        }
      };

    }, {}], 134: [function (require, module, exports) {
      (function (global) {

        /**
         * Module exports.
         */

        module.exports = deprecate;

        /**
         * Mark that a method should not be used.
         * Returns a modified function which warns once by default.
         *
         * If `localStorage.noDeprecation = true` is set, then it is a no-op.
         *
         * If `localStorage.throwDeprecation = true` is set, then deprecated functions
         * will throw an Error when invoked.
         *
         * If `localStorage.traceDeprecation = true` is set, then deprecated functions
         * will invoke `console.trace()` instead of `console.error()`.
         *
         * @param {Function} fn - the function to deprecate
         * @param {String} msg - the string to print to the console when `fn` is invoked
         * @returns {Function} a new "deprecated" version of `fn`
         * @api public
         */

        function deprecate(fn, msg) {
          if (config('noDeprecation')) {
            return fn;
          }

          var warned = false;
          function deprecated() {
            if (!warned) {
              if (config('throwDeprecation')) {
                throw new Error(msg);
              } else if (config('traceDeprecation')) {
                console.trace(msg);
              } else {
                console.warn(msg);
              }
              warned = true;
            }
            return fn.apply(this, arguments);
          }

          return deprecated;
        }

        /**
         * Checks `localStorage` for boolean values for the given `name`.
         *
         * @param {String} name
         * @returns {Boolean}
         * @api private
         */

        function config(name) {
          // accessing global.localStorage can trigger a DOMException in sandboxed iframes
          try {
            if (!global.localStorage) return false;
          } catch (_) {
            return false;
          }
          var val = global.localStorage[name];
          if (null == val) return false;
          return String(val).toLowerCase() === 'true';
        }

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}], 135: [function (require, module, exports) {
      module.exports = function isBuffer(arg) {
        return arg && typeof arg === 'object'
          && typeof arg.copy === 'function'
          && typeof arg.fill === 'function'
          && typeof arg.readUInt8 === 'function';
      }
    }, {}], 136: [function (require, module, exports) {
      (function (process, global) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        var formatRegExp = /%[sdj%]/g;
        exports.format = function (f) {
          if (!isString(f)) {
            var objects = [];
            for (var i = 0; i < arguments.length; i++) {
              objects.push(inspect(arguments[i]));
            }
            return objects.join(' ');
          }

          var i = 1;
          var args = arguments;
          var len = args.length;
          var str = String(f).replace(formatRegExp, function (x) {
            if (x === '%%') return '%';
            if (i >= len) return x;
            switch (x) {
              case '%s': return String(args[i++]);
              case '%d': return Number(args[i++]);
              case '%j':
                try {
                  return JSON.stringify(args[i++]);
                } catch (_) {
                  return '[Circular]';
                }
              default:
                return x;
            }
          });
          for (var x = args[i]; i < len; x = args[++i]) {
            if (isNull(x) || !isObject(x)) {
              str += ' ' + x;
            } else {
              str += ' ' + inspect(x);
            }
          }
          return str;
        };


        // Mark that a method should not be used.
        // Returns a modified function which warns once by default.
        // If --no-deprecation is set, then it is a no-op.
        exports.deprecate = function (fn, msg) {
          // Allow for deprecating things in the process of starting up.
          if (isUndefined(global.process)) {
            return function () {
              return exports.deprecate(fn, msg).apply(this, arguments);
            };
          }

          if (process.noDeprecation === true) {
            return fn;
          }

          var warned = false;
          function deprecated() {
            if (!warned) {
              if (process.throwDeprecation) {
                throw new Error(msg);
              } else if (process.traceDeprecation) {
                console.trace(msg);
              } else {
                console.error(msg);
              }
              warned = true;
            }
            return fn.apply(this, arguments);
          }

          return deprecated;
        };


        var debugs = {};
        var debugEnviron;
        exports.debuglog = function (set) {
          if (isUndefined(debugEnviron))
            debugEnviron = process.env.NODE_DEBUG || '';
          set = set.toUpperCase();
          if (!debugs[set]) {
            if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
              var pid = process.pid;
              debugs[set] = function () {
                var msg = exports.format.apply(exports, arguments);
                console.error('%s %d: %s', set, pid, msg);
              };
            } else {
              debugs[set] = function () { };
            }
          }
          return debugs[set];
        };


        /**
         * Echos the value of a value. Trys to print the value out
         * in the best way possible given the different types.
         *
         * @param {Object} obj The object to print out.
         * @param {Object} opts Optional options object that alters the output.
         */
        /* legacy: obj, showHidden, depth, colors*/
        function inspect(obj, opts) {
          // default options
          var ctx = {
            seen: [],
            stylize: stylizeNoColor
          };
          // legacy...
          if (arguments.length >= 3) ctx.depth = arguments[2];
          if (arguments.length >= 4) ctx.colors = arguments[3];
          if (isBoolean(opts)) {
            // legacy...
            ctx.showHidden = opts;
          } else if (opts) {
            // got an "options" object
            exports._extend(ctx, opts);
          }
          // set default options
          if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
          if (isUndefined(ctx.depth)) ctx.depth = 2;
          if (isUndefined(ctx.colors)) ctx.colors = false;
          if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
          if (ctx.colors) ctx.stylize = stylizeWithColor;
          return formatValue(ctx, obj, ctx.depth);
        }
        exports.inspect = inspect;


        // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
        inspect.colors = {
          'bold': [1, 22],
          'italic': [3, 23],
          'underline': [4, 24],
          'inverse': [7, 27],
          'white': [37, 39],
          'grey': [90, 39],
          'black': [30, 39],
          'blue': [34, 39],
          'cyan': [36, 39],
          'green': [32, 39],
          'magenta': [35, 39],
          'red': [31, 39],
          'yellow': [33, 39]
        };

        // Don't use 'blue' not visible on cmd.exe
        inspect.styles = {
          'special': 'cyan',
          'number': 'yellow',
          'boolean': 'yellow',
          'undefined': 'grey',
          'null': 'bold',
          'string': 'green',
          'date': 'magenta',
          // "name": intentionally not styling
          'regexp': 'red'
        };


        function stylizeWithColor(str, styleType) {
          var style = inspect.styles[styleType];

          if (style) {
            return '\u001b[' + inspect.colors[style][0] + 'm' + str +
              '\u001b[' + inspect.colors[style][1] + 'm';
          } else {
            return str;
          }
        }


        function stylizeNoColor(str, styleType) {
          return str;
        }


        function arrayToHash(array) {
          var hash = {};

          array.forEach(function (val, idx) {
            hash[val] = true;
          });

          return hash;
        }


        function formatValue(ctx, value, recurseTimes) {
          // Provide a hook for user-specified inspect functions.
          // Check that value is an object with an inspect function on it
          if (ctx.customInspect &&
            value &&
            isFunction(value.inspect) &&
            // Filter out the util module, it's inspect function is special
            value.inspect !== exports.inspect &&
            // Also filter out any prototype objects using the circular check.
            !(value.constructor && value.constructor.prototype === value)) {
            var ret = value.inspect(recurseTimes, ctx);
            if (!isString(ret)) {
              ret = formatValue(ctx, ret, recurseTimes);
            }
            return ret;
          }

          // Primitive types cannot have properties
          var primitive = formatPrimitive(ctx, value);
          if (primitive) {
            return primitive;
          }

          // Look up the keys of the object.
          var keys = Object.keys(value);
          var visibleKeys = arrayToHash(keys);

          if (ctx.showHidden) {
            keys = Object.getOwnPropertyNames(value);
          }

          // IE doesn't make error fields non-enumerable
          // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
          if (isError(value)
            && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
            return formatError(value);
          }

          // Some type of object without properties can be shortcutted.
          if (keys.length === 0) {
            if (isFunction(value)) {
              var name = value.name ? ': ' + value.name : '';
              return ctx.stylize('[Function' + name + ']', 'special');
            }
            if (isRegExp(value)) {
              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
            }
            if (isDate(value)) {
              return ctx.stylize(Date.prototype.toString.call(value), 'date');
            }
            if (isError(value)) {
              return formatError(value);
            }
          }

          var base = '', array = false, braces = ['{', '}'];

          // Make Array say that they are Array
          if (isArray(value)) {
            array = true;
            braces = ['[', ']'];
          }

          // Make functions say that they are functions
          if (isFunction(value)) {
            var n = value.name ? ': ' + value.name : '';
            base = ' [Function' + n + ']';
          }

          // Make RegExps say that they are RegExps
          if (isRegExp(value)) {
            base = ' ' + RegExp.prototype.toString.call(value);
          }

          // Make dates with properties first say the date
          if (isDate(value)) {
            base = ' ' + Date.prototype.toUTCString.call(value);
          }

          // Make error with message first say the error
          if (isError(value)) {
            base = ' ' + formatError(value);
          }

          if (keys.length === 0 && (!array || value.length == 0)) {
            return braces[0] + base + braces[1];
          }

          if (recurseTimes < 0) {
            if (isRegExp(value)) {
              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
            } else {
              return ctx.stylize('[Object]', 'special');
            }
          }

          ctx.seen.push(value);

          var output;
          if (array) {
            output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
          } else {
            output = keys.map(function (key) {
              return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
            });
          }

          ctx.seen.pop();

          return reduceToSingleString(output, base, braces);
        }


        function formatPrimitive(ctx, value) {
          if (isUndefined(value))
            return ctx.stylize('undefined', 'undefined');
          if (isString(value)) {
            var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
              .replace(/'/g, "\\'")
              .replace(/\\"/g, '"') + '\'';
            return ctx.stylize(simple, 'string');
          }
          if (isNumber(value))
            return ctx.stylize('' + value, 'number');
          if (isBoolean(value))
            return ctx.stylize('' + value, 'boolean');
          // For some reason typeof null is "object", so special case here.
          if (isNull(value))
            return ctx.stylize('null', 'null');
        }


        function formatError(value) {
          return '[' + Error.prototype.toString.call(value) + ']';
        }


        function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
          var output = [];
          for (var i = 0, l = value.length; i < l; ++i) {
            if (hasOwnProperty(value, String(i))) {
              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                String(i), true));
            } else {
              output.push('');
            }
          }
          keys.forEach(function (key) {
            if (!key.match(/^\d+$/)) {
              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                key, true));
            }
          });
          return output;
        }


        function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
          var name, str, desc;
          desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
          if (desc.get) {
            if (desc.set) {
              str = ctx.stylize('[Getter/Setter]', 'special');
            } else {
              str = ctx.stylize('[Getter]', 'special');
            }
          } else {
            if (desc.set) {
              str = ctx.stylize('[Setter]', 'special');
            }
          }
          if (!hasOwnProperty(visibleKeys, key)) {
            name = '[' + key + ']';
          }
          if (!str) {
            if (ctx.seen.indexOf(desc.value) < 0) {
              if (isNull(recurseTimes)) {
                str = formatValue(ctx, desc.value, null);
              } else {
                str = formatValue(ctx, desc.value, recurseTimes - 1);
              }
              if (str.indexOf('\n') > -1) {
                if (array) {
                  str = str.split('\n').map(function (line) {
                    return '  ' + line;
                  }).join('\n').substr(2);
                } else {
                  str = '\n' + str.split('\n').map(function (line) {
                    return '   ' + line;
                  }).join('\n');
                }
              }
            } else {
              str = ctx.stylize('[Circular]', 'special');
            }
          }
          if (isUndefined(name)) {
            if (array && key.match(/^\d+$/)) {
              return str;
            }
            name = JSON.stringify('' + key);
            if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
              name = name.substr(1, name.length - 2);
              name = ctx.stylize(name, 'name');
            } else {
              name = name.replace(/'/g, "\\'")
                .replace(/\\"/g, '"')
                .replace(/(^"|"$)/g, "'");
              name = ctx.stylize(name, 'string');
            }
          }

          return name + ': ' + str;
        }


        function reduceToSingleString(output, base, braces) {
          var numLinesEst = 0;
          var length = output.reduce(function (prev, cur) {
            numLinesEst++;
            if (cur.indexOf('\n') >= 0) numLinesEst++;
            return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
          }, 0);

          if (length > 60) {
            return braces[0] +
              (base === '' ? '' : base + '\n ') +
              ' ' +
              output.join(',\n  ') +
              ' ' +
              braces[1];
          }

          return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
        }


        // NOTE: These type checking functions intentionally don't use `instanceof`
        // because it is fragile and can be easily faked with `Object.create()`.
        function isArray(ar) {
          return Array.isArray(ar);
        }
        exports.isArray = isArray;

        function isBoolean(arg) {
          return typeof arg === 'boolean';
        }
        exports.isBoolean = isBoolean;

        function isNull(arg) {
          return arg === null;
        }
        exports.isNull = isNull;

        function isNullOrUndefined(arg) {
          return arg == null;
        }
        exports.isNullOrUndefined = isNullOrUndefined;

        function isNumber(arg) {
          return typeof arg === 'number';
        }
        exports.isNumber = isNumber;

        function isString(arg) {
          return typeof arg === 'string';
        }
        exports.isString = isString;

        function isSymbol(arg) {
          return typeof arg === 'symbol';
        }
        exports.isSymbol = isSymbol;

        function isUndefined(arg) {
          return arg === void 0;
        }
        exports.isUndefined = isUndefined;

        function isRegExp(re) {
          return isObject(re) && objectToString(re) === '[object RegExp]';
        }
        exports.isRegExp = isRegExp;

        function isObject(arg) {
          return typeof arg === 'object' && arg !== null;
        }
        exports.isObject = isObject;

        function isDate(d) {
          return isObject(d) && objectToString(d) === '[object Date]';
        }
        exports.isDate = isDate;

        function isError(e) {
          return isObject(e) &&
            (objectToString(e) === '[object Error]' || e instanceof Error);
        }
        exports.isError = isError;

        function isFunction(arg) {
          return typeof arg === 'function';
        }
        exports.isFunction = isFunction;

        function isPrimitive(arg) {
          return arg === null ||
            typeof arg === 'boolean' ||
            typeof arg === 'number' ||
            typeof arg === 'string' ||
            typeof arg === 'symbol' ||  // ES6 symbol
            typeof arg === 'undefined';
        }
        exports.isPrimitive = isPrimitive;

        exports.isBuffer = require('./support/isBuffer');

        function objectToString(o) {
          return Object.prototype.toString.call(o);
        }


        function pad(n) {
          return n < 10 ? '0' + n.toString(10) : n.toString(10);
        }


        var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
          'Oct', 'Nov', 'Dec'];

        // 26 Feb 16:19:34
        function timestamp() {
          var d = new Date();
          var time = [pad(d.getHours()),
          pad(d.getMinutes()),
          pad(d.getSeconds())].join(':');
          return [d.getDate(), months[d.getMonth()], time].join(' ');
        }


        // log is just a thin wrapper to console.log that prepends a timestamp
        exports.log = function () {
          console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
        };


        /**
         * Inherit the prototype methods from one constructor into another.
         *
         * The Function.prototype.inherits from lang.js rewritten as a standalone
         * function (not on Function.prototype). NOTE: If this file is to be loaded
         * during bootstrapping this function needs to be rewritten using some native
         * functions as prototype setup using normal JavaScript does not work as
         * expected during bootstrapping (see mirror.js in r114903).
         *
         * @param {function} ctor Constructor function which needs to inherit the
         *     prototype.
         * @param {function} superCtor Constructor function to inherit prototype from.
         */
        exports.inherits = require('inherits');

        exports._extend = function (origin, add) {
          // Don't do anything if add isn't an object
          if (!add || !isObject(add)) return origin;

          var keys = Object.keys(add);
          var i = keys.length;
          while (i--) {
            origin[keys[i]] = add[keys[i]];
          }
          return origin;
        };

        function hasOwnProperty(obj, prop) {
          return Object.prototype.hasOwnProperty.call(obj, prop);
        }

      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, { "./support/isBuffer": 135, "_process": 100, "inherits": 88 }], 137: [function (require, module, exports) {
      (function (process, global) {
        'use strict'

        var Transform = require('readable-stream').Transform
        var duplexify = require('duplexify')
        var WS = require('ws')
        var Buffer = require('safe-buffer').Buffer

        module.exports = WebSocketStream

        function buildProxy(options, socketWrite, socketEnd) {
          var proxy = new Transform({
            objectMode: options.objectMode
          })

          proxy._write = socketWrite
          proxy._flush = socketEnd

          return proxy
        }

        function WebSocketStream(target, protocols, options) {
          var stream, socket

          var isBrowser = process.title === 'browser'
          var isNative = !!global.WebSocket
          var socketWrite = isBrowser ? socketWriteBrowser : socketWriteNode

          if (protocols && !Array.isArray(protocols) && 'object' === typeof protocols) {
            // accept the "options" Object as the 2nd argument
            options = protocols
            protocols = null

            if (typeof options.protocol === 'string' || Array.isArray(options.protocol)) {
              protocols = options.protocol;
            }
          }

          if (!options) options = {}

          if (options.objectMode === undefined) {
            options.objectMode = !(options.binary === true || options.binary === undefined)
          }

          var proxy = buildProxy(options, socketWrite, socketEnd)

          if (!options.objectMode) {
            proxy._writev = writev
          }

          // browser only: sets the maximum socket buffer size before throttling
          var bufferSize = options.browserBufferSize || 1024 * 512

          // browser only: how long to wait when throttling
          var bufferTimeout = options.browserBufferTimeout || 1000

          // use existing WebSocket object that was passed in
          if (typeof target === 'object') {
            socket = target
            // otherwise make a new one
          } else {
            // special constructor treatment for native websockets in browsers, see
            // https://github.com/maxogden/websocket-stream/issues/82
            if (isNative && isBrowser) {
              socket = new WS(target, protocols)
            } else {
              socket = new WS(target, protocols, options)
            }

            socket.binaryType = 'arraybuffer'
          }

          // was already open when passed in
          if (socket.readyState === socket.OPEN) {
            stream = proxy
          } else {
            stream = duplexify.obj()
            socket.onopen = onopen
          }

          stream.socket = socket

          socket.onclose = onclose
          socket.onerror = onerror
          socket.onmessage = onmessage

          proxy.on('close', destroy)

          var coerceToBuffer = !options.objectMode

          function socketWriteNode(chunk, enc, next) {
            // avoid errors, this never happens unless
            // destroy() is called
            if (socket.readyState !== socket.OPEN) {
              next()
              return
            }

            if (coerceToBuffer && typeof chunk === 'string') {
              chunk = Buffer.from(chunk, 'utf8')
            }
            socket.send(chunk, next)
          }

          function socketWriteBrowser(chunk, enc, next) {
            if (socket.bufferedAmount > bufferSize) {
              setTimeout(socketWriteBrowser, bufferTimeout, chunk, enc, next)
              return
            }

            if (coerceToBuffer && typeof chunk === 'string') {
              chunk = Buffer.from(chunk, 'utf8')
            }

            try {
              socket.send(chunk)
            } catch (err) {
              return next(err)
            }

            next()
          }

          function socketEnd(done) {
            socket.close()
            done()
          }

          function onopen() {
            stream.setReadable(proxy)
            stream.setWritable(proxy)
            stream.emit('connect')
          }

          function onclose() {
            stream.end()
            stream.destroy()
          }

          function onerror(err) {
            stream.destroy(err)
          }

          function onmessage(event) {
            var data = event.data
            if (data instanceof ArrayBuffer) data = Buffer.from(data)
            else data = Buffer.from(data, 'utf8')
            proxy.push(data)
          }

          function destroy() {
            socket.close()
          }

          // this is to be enabled only if objectMode is false
          function writev(chunks, cb) {
            var buffers = new Array(chunks.length)
            for (var i = 0; i < chunks.length; i++) {
              if (typeof chunks[i].chunk === 'string') {
                buffers[i] = Buffer.from(chunks[i], 'utf8')
              } else {
                buffers[i] = chunks[i].chunk
              }
            }

            this._write(Buffer.concat(buffers), 'binary', cb)
          }

          return stream
        }

      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, { "_process": 100, "duplexify": 19, "readable-stream": 116, "safe-buffer": 118, "ws": 138 }], 138: [function (require, module, exports) {

      var ws = null

      if (typeof WebSocket !== 'undefined') {
        ws = WebSocket
      } else if (typeof MozWebSocket !== 'undefined') {
        ws = MozWebSocket
      } else if (typeof window !== 'undefined') {
        ws = window.WebSocket || window.MozWebSocket
      }

      module.exports = ws

    }, {}], 139: [function (require, module, exports) {
      // Returns a wrapper function that returns a wrapped callback
      // The wrapper function should do some stuff, and return a
      // presumably different callback function.
      // This makes sure that own properties are retained, so that
      // decorations and such are not lost along the way.
      module.exports = wrappy
      function wrappy(fn, cb) {
        if (fn && cb) return wrappy(fn)(cb)

        if (typeof fn !== 'function')
          throw new TypeError('need wrapper function')

        Object.keys(fn).forEach(function (k) {
          wrapper[k] = fn[k]
        })

        return wrapper

        function wrapper() {
          var args = new Array(arguments.length)
          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i]
          }
          var ret = fn.apply(this, args)
          var cb = args[args.length - 1]
          if (typeof ret === 'function' && ret !== cb) {
            Object.keys(cb).forEach(function (k) {
              ret[k] = cb[k]
            })
          }
          return ret
        }
      }

    }, {}], 140: [function (require, module, exports) {
      module.exports = extend

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      function extend() {
        var target = {}

        for (var i = 0; i < arguments.length; i++) {
          var source = arguments[i]

          for (var key in source) {
            if (hasOwnProperty.call(source, key)) {
              target[key] = source[key]
            }
          }
        }

        return target
      }

    }, {}]
  }, {}, [9])(9)
});
